TOC

Pythonの文字列と文字データ

Pythonの文字列と文字データ

Basic Data Types in Pythonのチュートリアルでは、文字データのシーケンスを含むstrings:オブジェクトを定義する方法を学びました。 文字データの処理はプログラミングに不可欠です。 少なくともある程度は文字列を操作する必要のない、まれなアプリケーションです。

Here’s what you’ll learn in this tutorial: Pythonは、文字列を操作するための豊富な演算子、関数、およびメソッドのセットを提供します。 このチュートリアルを終了すると、文字列の一部にアクセスして抽出する方法がわかります。また、文字列データを操作および変更するために使用できるメソッドについても理解できます。

また、生のバイトデータを表すために使用される他の2つのPythonオブジェクト、bytes型とbytearray型についても紹介します。

__ Take the Quiz:インタラクティブな「Python文字列と文字データ」クイズで知識をテストします。 完了すると、学習の進捗状況を経時的に追跡できるようにスコアを受け取ります。

クイズに答える»

文字列操作

以下のセクションでは、文字列の操作に使用できる演算子、メソッド、および関数を強調しています。

文字列演算子

Operators and Expressions in Pythonのチュートリアルで、演算子+と*が数値オペランドに適用されるのを見てきました。 これらの2つの演算子は、文字列にも適用できます。

+演算子

+演算子は、文字列を連結します。 次に示すように、結合されたオペランドで構成される文字列を返します。

>>> 

>>> s = 'foo'
>>> t = 'bar'
>>> u = 'baz'

>>> s + t
'foobar'
>>> s + t + u
'foobarbaz'

>>> print('Go team' + '!!!')
Go team!!!
*演算子

*演算子は、文字列の複数のコピーを作成します。 sが文字列で、nが整数の場合、次の式のいずれかが、sのn連結コピーで構成される文字列を返します。

s * n
n * s

両方の形式の例を次に示します。

>>> 

>>> s = 'foo.'

>>> s * 4
'foo.foo.foo.foo.'
>>> 4 * s
'foo.foo.foo.foo.'

乗数オペランドnは整数でなければなりません。 正の整数である必要があると思いますが、面白いことに、ゼロまたは負の値になる可能性があります。その場合、結果は空の文字列になります。

>>> 

>>> 'foo' * -8
''

文字列変数を作成し、それに値'foo' * -8を割り当てて空の文字列に初期化する場合、誰もがあなたが少し頭がおかしいと思うでしょう。 しかし、それはうまくいくでしょう。

in演算子

Pythonは、文字列で使用できるメンバーシップ演算子も提供します。 in演算子は、最初のオペランドが2番目のオペランドに含まれている場合はTrueを返し、それ以外の場合はFalseを返します。

>>> 

>>> s = 'foo'

>>> s in 'That\'s food for thought.'
True
>>> s in 'That\'s good for now.'
False

逆のnot in演算子もあります。

>>> 

>>> 'z' not in 'abc'
True
>>> 'z' not in 'xyz'
False

組み込みの文字列関数

Basic Data Types in Pythonのチュートリアルで見たように、Pythonはインタープリターに組み込まれていて、いつでも利用できる多くの関数を提供します。 文字列を扱ういくつかの例を次に示します。

関数 説明

chr()

整数を文字に変換します

ord()

文字を整数に変換します

len()

文字列の長さを返します

str()

オブジェクトの文字列表現を返します

これらについては、以下で詳しく説明します。

ord(c)

指定された文字の整数値を返します。

最も基本的なレベルでは、コンピューターはすべての情報を数値として保存します。 文字データを表すために、各文字をその代表番号にマッピングする変換スキームが使用されます。

一般的に使用されている最も単純なスキームは、ASCIIと呼ばれます。 おそらく最もよく使い慣れている一般的なラテン文字を網羅しています。 これらの文字の場合、ord(c)は文字cのASCII値を返します。

>>> 

>>> ord('a')
97
>>> ord('#')
35

ASCIIはそれで十分です。 しかし、世界ではさまざまな言語が使用されており、デジタルメディアに登場する無数の記号やグリフがあります。 コンピュータコードで表現する必要がある可能性のある文字の完全なセットは、通常表示される通常のラテン文字、数字、記号をはるかに超えています。

Unicodeは、すべての可能なプラットフォームで、すべての可能な言語で、すべての可能な文字に数値コードを提供しようとする野心的な標準です。 Python 3は、文字列内にUnicode文字を許可するなど、Unicodeを幅広くサポートしています。

For More Information: PythonドキュメントのPython’s Unicode Supportを参照してください。

一般的な文字の領域にいる限り、ASCIIとUnicodeの実用的な違いはほとんどありません。 ただし、ord()関数はUnicode文字の数値も返します。

>>> 

>>> ord('€')
8364
>>> ord('∑')
8721
chr(n)

指定された整数の文字値を返します。

chr()はord()の逆を行います。 数値nが与えられると、chr(n)はnに対応する文字を表す文字列を返します。

>>> 

>>> chr(97)
'a'
>>> chr(35)
'#'

chr()はUnicode文字も処理します。

>>> 

>>> chr(8364)
'€'
>>> chr(8721)
'∑'

len(s)

文字列の長さを返します。

len()を使用すると、Pythonの文字列の長さを確認できます。 len(s)は、sの文字数を返します。

>>> 

>>> s = 'I am a string.'
>>> len(s)
14

str(obj)

オブジェクトの文字列表現を返します。

実質的にPythonのオブジェクトはすべて文字列としてレンダリングできます。 str(obj)は、オブジェクトobjの文字列表現を返します。

>>> 

>>> str(49.2)
'49.2'
>>> str(3+4j)
'(3+4j)'
>>> str(3 + 29)
'32'
>>> str('foo')
'foo'

文字列のインデックス付け

多くの場合、プログラミング言語では、数値のインデックスまたはキー値を使用して、順序付けされたデータの個々のアイテムに直接アクセスできます。 このプロセスは、インデックス付けと呼ばれます。

Pythonでは、文字列は文字データの順序付けられたシーケンスであるため、この方法でインデックスを作成できます。 文字列内の個々の文字にアクセスするには、文字列名の後に角かっこ（[]）で囲んだ数字を指定します。

Pythonの文字列インデックスはゼロベースです。文字列の最初の文字のインデックスは0で、次の文字のインデックスは1というように続きます。 最後の文字のインデックスは、文字列の長さから1を引いたものになります。

たとえば、文字列'foobar'のインデックスの概略図は次のようになります。

個々の文字には、次のようにインデックスでアクセスできます。

>>> 

>>> s = 'foobar'

>>> s[0]
'f'
>>> s[1]
'o'
>>> s[3]
'b'
>>> len(s)
6
>>> s[len(s)-1]
'r'

文字列の末尾を超えてインデックスを作成しようとすると、エラーが発生します。

>>> 

>>> s[6]
Traceback (most recent call last):
  File "", line 1, in 
    s[6]
IndexError: string index out of range

文字列インデックスは負の数で指定することもできます。この場合、インデックスは文字列の末尾から逆方向に発生します。-1は最後の文字を参照し、-2は最後から2番目の文字を参照します。 。 これは、文字列'foobar'への正と負の両方のインデックスを示す同じ図です。

ネガティブインデックスの例を次に示します。

>>> 

>>> s = 'foobar'

>>> s[-1]
'r'
>>> s[-2]
'a'
>>> len(s)
6
>>> s[-len(s)]
'f'

文字列の先頭を超える負の数でインデックスを作成しようとすると、エラーが発生します。

>>> 

>>> s[-7]
Traceback (most recent call last):
  File "", line 1, in 
    s[-7]
IndexError: string index out of range

空でない文字列sの場合、s[len(s)-1]とs[-1]は両方とも最後の文字を返します。 空の文字列に意味のあるインデックスはありません。

ストリングスライシング

Pythonでは、文字列スライスと呼ばれる、文字列から部分文字列を抽出する形式のインデックス構文も使用できます。 sが文字列の場合、s[m:n]の形式の式は、位置mから始まり、位置nまでのsの部分を返します。 ：

>>> 

>>> s = 'foobar'
>>> s[2:5]
'oba'

Remember:文字列インデックスはゼロベースです。 文字列の最初の文字のインデックスは0です。 これは、標準のインデックス付けとスライスの両方に適用されます。

この場合も、2番目のインデックスは、結果に含まれない最初の文字（上記の例では文字'r'（s[5]））を指定します。 これは少し直感的ではないように思われるかもしれませんが、この結果は理にかなっています。式s[m:n]は、長さがn - m文字の部分文字列（この場合は5 - 2 = 3）を返します。

最初のインデックスを省略すると、スライスは文字列の先頭から始まります。 したがって、s[:m]とs[0:m]は同等です。

>>> 

>>> s = 'foobar'

>>> s[:4]
'foob'
>>> s[0:4]
'foob'

同様に、s[n:]のように2番目のインデックスを省略すると、スライスは最初のインデックスから文字列の終わりまで拡張されます。 これは、より面倒なs[n:len(s)]の代わりに、簡潔でわかりやすい方法です。

>>> 

>>> s = 'foobar'

>>> s[2:]
'obar'
>>> s[2:len(s)]
'obar'

任意の文字列sおよび任意の整数n（0 ≤ n ≤ len(s)）の場合、s[:n] + s[n:]はsと等しくなります。

>>> 

>>> s = 'foobar'

>>> s[:4] + s[4:]
'foobar'
>>> s[:4] + s[4:] == s
True

両方のインデックスを省略すると、元の文字列全体が返されます。 文字通り。 これはコピーではなく、元の文字列への参照です。

>>> 

>>> s = 'foobar'
>>> t = s[:]
>>> id(s)
59598496
>>> id(t)
59598496
>>> s is t
True

スライスの最初のインデックスが2番目のインデックス以上の場合、Pythonは空の文字列を返します。 これは、探している場合に空の文字列を生成するもう1つの難読化された方法です。

>>> 

>>> s[2:2]
''
>>> s[4:2]
''

スライスとともに負のインデックスも使用できます。 -1は最後の文字を参照し、-2は最後から2番目の文字を参照し、以下同様に単純なインデックス付けと同じです。 次の図は、正と負の両方のインデックスを使用して、文字列'foobar'から部分文字列'oob'をスライスする方法を示しています。

対応するPythonコードは次のとおりです。

>>> 

>>> s = 'foobar'

>>> s[-5:-2]
'oob'
>>> s[1:4]
'oob'
>>> s[-5:-2] == s[1:4]
True

文字列スライスでストライドを指定する

議論するスライス構文のもう1つのバリアントがあります。 追加の:と3番目のインデックスを追加すると、ストライド（ステップとも呼ばれます）が指定されます。これは、スライス内の各文字を取得した後にジャンプする文字数を示します。

たとえば、文字列'foobar'の場合、スライス0:6:2は最初の文字で始まり、最後の文字（文字列全体）で終わり、2文字おきにスキップされます。 これを次の図に示します。

同様に、1:6:2は、2番目の文字（インデックス1）で始まり、最後の文字で終わるスライスを指定します。また、ストライド値2により、他のすべての文字がスキップされます。

例示的なREPLコードを次に示します。

>>> 

>>> s = 'foobar'

>>> s[0:6:2]
'foa'

>>> s[1:6:2]
'obr'

スライスと同様に、最初と2番目のインデックスは省略でき、デフォルトではそれぞれ最初と最後の文字になります。

>>> 

>>> s = '12345' * 5
>>> s
'1234512345123451234512345'
>>> s[::5]
'11111'
>>> s[4::5]
'55555'

負のストライド値も指定できます。この場合、Pythonは文字列を逆方向にステップします。 その場合、開始/最初のインデックスは終了/ 2番目のインデックスよりも大きくする必要があります。

>>> 

>>> s = 'foobar'
>>> s[5:0:-2]
'rbo'

上記の例では、5:0:-2は、「最後の文字から開始し、最初の文字まで、2だけ後退する」ことを意味します。

後方に移動するときに、最初と2番目のインデックスを省略すると、デフォルトは直感的な方法で逆になります。最初のインデックスはデフォルトで文字列の終わりになり、2番目のインデックスはデフォルトで始まります。 これが一例です。

>>> 

>>> s = '12345' * 5
>>> s
'1234512345123451234512345'
>>> s[::-5]
'55555'

これは、文字列を逆にするための一般的なパラダイムです。

>>> 

>>> s = 'If Comrade Napoleon says it, it must be right.'
>>> s[::-1]
'.thgir eb tsum ti ,ti syas noelopaN edarmoC fI'

変数を文字列に補間する

Pythonバージョン3.6では、新しい文字列フォーマットメカニズムが導入されました。 この機能は、正式にはFormatted String Literalと呼ばれますが、通常はニックネームf-stringで呼ばれます。

f-stringsが提供するフォーマット機能は広範囲にわたるため、ここでは詳しく説明しません。 詳細については、Real Pythonの記事Python 3’s f-Strings: An Improved String Formatting Syntax (Guide)をご覧ください。 このシリーズの後半で、f-stringsをより深く掘り下げるFormatted Outputに関するチュートリアルもあります。

すぐに使用を開始できるf文字列の簡単な機能の1つは、変数補間です。 f-stringリテラル内で変数名を直接指定できます。Pythonは、名前を対応する値に置き換えます。

たとえば、算術計算の結果を表示するとします。 これは、数値と文字列リテラルをコンマで区切って、簡単なprint()ステートメントで行うことができます。

>>> 

>>> n = 20
>>> m = 25
>>> prod = n * m
>>> print('The product of', n, 'and', m, 'is', prod)
The product of 20 and 25 is 500

しかし、これは面倒です。 f-stringを使用して同じことを達成するには：

  • 文字列リテラルの開始引用符の直前に、小文字のfまたは大文字のFを指定します。 これは、Pythonに標準文字列ではなくf文字列であることを伝えます。

  • 中括弧（{}）で補間する変数を指定します。

f文字列を使用してリキャストすると、上記の例ははるかにきれいに見えます。

>>> 

>>> n = 20
>>> m = 25
>>> prod = n * m
>>> print(f'The product of {n} and {m} is {prod}')
The product of 20 and 25 is 500

Pythonの3つの引用メカニズムのいずれかを使用して、f文字列を定義できます。

>>> 

>>> var = 'Bark'

>>> print(f'A dog says {var}!')
A dog says Bark!
>>> print(f"A dog says {var}!")
A dog says Bark!
>>> print(f'''A dog says {var}!''')
A dog says Bark!

文字列の変更

一言で言えば、できません。 文字列は、Pythonが不変と見なすデータ型の1つであり、変更できないことを意味します。 実際、これまでに見てきたすべてのデータ型は不変です。 （すぐにわかるように、Pythonは変更可能なデータ型を提供します。）

このようなステートメントはエラーを引き起こします：

>>> 

>>> s = 'foobar'
>>> s[3] = 'x'
Traceback (most recent call last):
  File "", line 1, in 
    s[3] = 'x'
TypeError: 'str' object does not support item assignment

実際、文字列を変更する必要はほとんどありません。 通常、必要な変更が加えられた元の文字列のコピーを生成することにより、簡単に目的を達成できます。 Pythonでこれを行うには非常に多くの方法があります。 1つの可能性があります。

>>> 

>>> s = s[:3] + 'x' + s[4:]
>>> s
'fooxar'

これを実現する組み込みの文字列メソッドもあります。

>>> 

>>> s = 'foobar'
>>> s = s.replace('b', 'x')
>>> s
'fooxar'

組み込みの文字列メソッドの詳細についてはこちらをお読みください！

組み込みの文字列メソッド

Variables in Pythonのチュートリアルで、Pythonは非常にオブジェクト指向の言語であることを学びました。 Pythonプログラムのすべてのデータ項目はオブジェクトです。

また、特定のタスクを実行するために呼び出すことができる呼び出し可能なプロシージャの機能にも精通しています。

メソッドは関数に似ています。 メソッドとは、オブジェクトに密接に関連付けられている呼び出し可能なプロシージャの特殊なタイプです。 関数と同様に、メソッドは個別のタスクを実行するために呼び出されますが、特定のオブジェクトで呼び出され、実行中にターゲットオブジェクトの情報を持ちます。

オブジェクトのメソッドを呼び出すための構文は次のとおりです。 

obj.foo()

これにより、オブジェクトobjでメソッド.foo()が呼び出されます。 <args>は、メソッドに渡される引数を指定します（存在する場合）。

メソッドの定義と呼び出しについては、オブジェクト指向プログラミングの説明の後半で詳しく説明します。 現在のところ、目標は、Pythonが文字列オブジェクトを操作するためにサポートする、より一般的に使用される組み込みメソッドのいくつかを提示することです。

以下のメソッド定義では、角括弧（[]）で指定された引数はオプションです。

ケース変換

このグループのメソッドは、ターゲット文字列の大文字と小文字の変換を実行します。

s.capitalize()

ターゲット文字列を大文字にします。

s.capitalize()は、最初の文字が大文字に変換され、他のすべての文字が小文字に変換されたsのコピーを返します。

>>> 

>>> s = 'foO BaR BAZ quX'
>>> s.capitalize()
'Foo bar baz qux'

アルファベット以外の文字は変更されません：

>>> 

>>> s = 'foo123#BAR#.'
>>> s.capitalize()
'Foo123#bar#.'

s.lower()

アルファベット文字を小文字に変換します。

s.lower()は、すべてのアルファベット文字が小文字に変換されたsのコピーを返します。

>>> 

>>> 'FOO Bar 123 baz qUX'.lower()
'foo bar 123 baz qux'

s.swapcase()

アルファベット文字の大文字と小文字を入れ替えます。

s.swapcase()は、大文字のアルファベット文字を小文字に、またはその逆に変換したsのコピーを返します。

>>> 

>>> 'FOO Bar 123 baz qUX'.swapcase()
'foo bAR 123 BAZ Qux'

s.title()

ターゲット文字列を「タイトルケース」に変換します。

s.title()は、各単語の最初の文字が大文字に変換され、残りの文字が小文字であるsのコピーを返します。

>>> 

>>> 'the sun also rises'.title()
'The Sun Also Rises'

このメソッドは、かなり単純なアルゴリズムを使用します。 重要な単語と重要でない単語を区別しようとせず、アポストロフィ、所有格、または頭字語を適切に処理しません。

>>> 

>>> "what's happened to ted's IBM stock?".title()
"What'S Happened To Ted'S Ibm Stock?"

s.upper()

アルファベット文字を大文字に変換します。

s.upper()は、すべてのアルファベット文字が大文字に変換されたsのコピーを返します。

>>> 

>>> 'FOO Bar 123 baz qUX'.upper()
'FOO BAR 123 BAZ QUX'
検索と置換

これらのメソッドは、指定された部分文字列のターゲット文字列を検索するさまざまな手段を提供します。

このグループの各メソッドは、オプションの<start>および<end>引数をサポートします。 これらは文字列スライスの場合と同様に解釈されます。メソッドのアクションは、文字位置<start>から始まり、文字位置<end>まで続くターゲット文字列の部分に制限されます。 <start>が指定されているが、<end>が指定されていない場合、このメソッドは、ターゲット文字列の<start>から文字列の終わりまでの部分に適用されます。

s.count([, [, ]])

ターゲット文字列内の部分文字列の出現をカウントします。

s.count(<sub>)は、s内の部分文字列<sub>の重複しないオカレンスの数を返します。

>>> 

>>> 'foo goo moo'.count('oo')
3

カウントは、<start>および<end>で示される部分文字列内の出現回数に制限されます（指定されている場合）。

>>> 

>>> 'foo goo moo'.count('oo', 0, 8)
2

s.endswith([, [, ]])

ターゲット文字列が特定の部分文字列で終わるかどうかを判断します。

s.endswith(<suffix>)は、sが指定された<suffix>で終了する場合はTrueを返し、それ以外の場合はFalseを返します。

>>> 

>>> 'foobar'.endswith('bar')
True
>>> 'foobar'.endswith('baz')
False

比較は、<start>および<end>で示される部分文字列に制限されます（指定されている場合）。

>>> 

>>> 'foobar'.endswith('oob', 0, 4)
True
>>> 'foobar'.endswith('oob', 2, 4)
False

s.find([, [, ]])

指定されたサブストリングのターゲットストリングを検索します。

.find()を使用して、Python文字列に特定の部分文字列が含まれているかどうかを確認できます。 s.find(<sub>)は、部分文字列<sub>が見つかったsの最小インデックスを返します。

>>> 

>>> 'foo bar foo baz foo qux'.find('foo')
0

指定された部分文字列が見つからない場合、このメソッドは-1を返します。

>>> 

>>> 'foo bar foo baz foo qux'.find('grault')
-1

以下に指定されている場合、検索は<start>および<end>で示される部分文字列に制限されます。

>>> 

>>> 'foo bar foo baz foo qux'.find('foo', 4)
8
>>> 'foo bar foo baz foo qux'.find('foo', 4, 7)
-1

s.index([, [, ]])

指定されたサブストリングのターゲットストリングを検索します。

このメソッドは、-1を返すのではなく、<sub>が見つからない場合に例外を発生させることを除いて、.find()と同じです。

>>> 

>>> 'foo bar foo baz foo qux'.index('grault')
Traceback (most recent call last):
  File "", line 1, in 
    'foo bar foo baz foo qux'.index('grault')
ValueError: substring not found

s.rfind([, [, ]])

指定された部分文字列の末尾からターゲット文字列を検索します。

s.rfind(<sub>)は、部分文字列<sub>が見つかったsの最高のインデックスを返します。

>>> 

>>> 'foo bar foo baz foo qux'.rfind('foo')
16

.find()と同様に、部分文字列が見つからない場合、-1が返されます。

>>> 

>>> 'foo bar foo baz foo qux'.rfind('grault')
-1

以下に指定されている場合、検索は<start>および<end>で示される部分文字列に制限されます。

>>> 

>>> 'foo bar foo baz foo qux'.rfind('foo', 0, 14)
8
>>> 'foo bar foo baz foo qux'.rfind('foo', 10, 14)
-1

s.rindex([, [, ]])

指定された部分文字列の末尾からターゲット文字列を検索します。

このメソッドは、-1を返すのではなく、<sub>が見つからない場合に例外を発生させることを除いて、.rfind()と同じです。

>>> 

>>> 'foo bar foo baz foo qux'.rindex('grault')
Traceback (most recent call last):
  File "", line 1, in 
    'foo bar foo baz foo qux'.rindex('grault')
ValueError: substring not found

s.startswith([, [, ]])

ターゲット文字列が指定された部分文字列で始まるかどうかを決定します。

Pythonの.startswith()メソッドを使用する場合、sが指定された<suffix>で始まる場合、s.startswith(<suffix>)はTrueを返し、それ以外の場合はFalseを返します。

>>> 

>>> 'foobar'.startswith('foo')
True
>>> 'foobar'.startswith('bar')
False

比較は、<start>および<end>で示される部分文字列に制限されます（指定されている場合）。

>>> 

>>> 'foobar'.startswith('bar', 3)
True
>>> 'foobar'.startswith('bar', 3, 2)
False
キャラクター分類

このグループのメソッドは、含まれる文字に基づいて文字列を分類します。

s.isalnum()

ターゲット文字列が英数字で構成されるかどうかを決定します。

s.isalnum()は、sが空でなく、そのすべての文字が英数字（文字または数字）の場合はTrueを返し、それ以外の場合はFalseを返します。

>>> 

>>> 'abc123'.isalnum()
True
>>> 'abc$123'.isalnum()
False
>>> ''.isalnum()
False

s.isalpha()

ターゲット文字列がアルファベット文字で構成されるかどうかを決定します。

s.isalpha()は、sが空でなく、そのすべての文字がアルファベットの場合はTrueを返し、それ以外の場合はFalseを返します。

>>> 

>>> 'ABCabc'.isalpha()
True
>>> 'abc123'.isalpha()
False

s.isdigit()

ターゲット文字列が数字で構成されているかどうかを判断します。

.isdigit() Pythonメソッドを使用して、文字列が数字のみで構成されているかどうかを確認できます。 s.digit()は、sが空でなく、そのすべての文字が数字の場合はTrueを返し、それ以外の場合はFalseを返します。

>>> 

>>> '123'.isdigit()
True
>>> '123abc'.isdigit()
False

s.isidentifier()

ターゲット文字列が有効なPython識別子かどうかを判断します。

s.isidentifier()は、sが言語定義に従って有効なPython識別子である場合はTrueを返し、それ以外の場合はFalseを返します。

>>> 

>>> 'foo32'.isidentifier()
True
>>> '32foo'.isidentifier()
False
>>> 'foo$32'.isidentifier()
False

Note:.isidentifier()は、実際には有効な識別子ではない場合でも、Pythonキーワードに一致する文字列に対してTrueを返します。

>>> 

>>> 'and'.isidentifier()
True

keywordというモジュールに含まれているiskeyword()という関数を使用して、文字列がPythonキーワードと一致するかどうかをテストできます。 これを行う1つの可能な方法を以下に示します。

>>> 

>>> from keyword import iskeyword
>>> iskeyword('and')
True

文字列が有効なPython識別子として機能することを本当に確認したい場合は、.isidentifier()がTrueであり、iskeyword()がFalseであることを確認する必要があります。

Pythonモジュールの詳細については、Python Modules and Packages—An Introductionを参照してください。

s.islower()

ターゲット文字列のアルファベット文字が小文字かどうかを決定します。

s.islower()は、sが空でなく、含まれるすべての英字が小文字の場合はTrueを返し、それ以外の場合はFalseを返します。 アルファベット以外の文字は無視されます：

>>> 

>>> 'abc'.islower()
True
>>> 'abc1$d'.islower()
True
>>> 'Abc1$D'.islower()
False

s.isprintable()

ターゲット文字列が完全に印刷可能な文字で構成されるかどうかを決定します。

s.isprintable()は、sが空の場合、またはそれに含まれるすべての英字が印刷可能である場合、Trueを返します。 sに印刷不可能な文字が少なくとも1つ含まれている場合は、Falseを返します。 アルファベット以外の文字は無視されます：

>>> 

>>> 'a\tb'.isprintable()
False
>>> 'a b'.isprintable()
True
>>> ''.isprintable()
True
>>> 'a\nb'.isprintable()
False

Note:これは、sが空の文字列である場合にTrueを返す唯一の.isxxxx()メソッドです。 他のすべては、空の文字列に対してFalseを返します。

s.isspace()

ターゲット文字列が空白文字で構成されるかどうかを決定します。

s.isspace()は、sが空でなく、すべての文字が空白文字である場合はTrueを返し、それ以外の場合はFalseを返します。

最も一般的に使用される空白文字は、スペース' '、タブ' '、および改行' 'です。

>>> 

>>> ' \t \n '.isspace()
True
>>> '   a   '.isspace()
False

ただし、空白として適格な他のASCII文字がいくつかあります。Unicode文字を考慮すると、それ以外にもかなりの数があります。

>>> 

>>> '\f\u2005\r'.isspace()
True

（' 'および' 'は、ASCII改ページおよびキャリッジリターン文字のエスケープシーケンスです。' 'は、Unicode Four-Per-Em Spaceのエスケープシーケンスです。）

s.istitle()

ターゲット文字列がタイトルの大文字小文字を区別するかどうかを決定します。

sが空でなく、各単語の最初の英字が大文字で、各単語の他のすべての英字が小文字の場合、s.istitle()はTrueを返します。 それ以外の場合はFalseを返します。

>>> 

>>> 'This Is A Title'.istitle()
True
>>> 'This is a title'.istitle()
False
>>> 'Give Me The #$#@ Ball!'.istitle()
True

Note:これがより直感的である場合に備えて、Pythonドキュメントで.istitle()がどのように説明されているかを示します。

s.isupper()

ターゲット文字列のアルファベット文字が大文字かどうかを決定します。

s.isupper()は、sが空でなく、含まれるすべての英字が大文字の場合はTrueを返し、それ以外の場合はFalseを返します。 アルファベット以外の文字は無視されます：

>>> 

>>> 'ABC'.isupper()
True
>>> 'ABC1$D'.isupper()
True
>>> 'Abc1$D'.isupper()
False
文字列のフォーマット

このグループのメソッドは、文字列の形式を変更または拡張します。

s.center([, ])

文字列をフィールドの中央に配置します。

s.center(<width>)は、幅<width>のフィールドを中心とするsで構成される文字列を返します。 デフォルトでは、パディングはASCIIスペース文字で構成されます。

>>> 

>>> 'foo'.center(10)
'   foo    '

オプションの<fill>引数が指定されている場合、それはパディング文字として使用されます。

>>> 

>>> 'bar'.center(10, '-')
'---bar----'

sがすでに少なくとも<width>と同じ長さである場合、変更されずに返されます。

>>> 

>>> 'foo'.center(2)
'foo'

s.expandtabs(tabsize=8)

文字列内のタブを展開します。

s.expandtabs()は、各タブ文字（' '）をスペースに置き換えます。 デフォルトでは、8列ごとにタブストップを想定してスペースが埋められます。

>>> 

>>> 'a\tb\tc'.expandtabs()
'a       b       c'
>>> 'aaa\tbbb\tc'.expandtabs()
'aaa     bbb     c'

tabsizeは、代替タブストップ列を指定するオプションのキーワードパラメーターです。

>>> 

>>> 'a\tb\tc'.expandtabs(4)
'a   b   c'
>>> 'aaa\tbbb\tc'.expandtabs(tabsize=4)
'aaa bbb c'

s.ljust([, ])

フィールド内の文字列を左揃えにします。

s.ljust(<width>)は、幅<width>のフィールドで左寄せされたsで構成される文字列を返します。 デフォルトでは、パディングはASCIIスペース文字で構成されます。

>>> 

>>> 'foo'.ljust(10)
'foo       '

オプションの<fill>引数が指定されている場合、それはパディング文字として使用されます。

>>> 

>>> 'foo'.ljust(10, '-')
'foo-------'

sがすでに少なくとも<width>と同じ長さである場合、変更されずに返されます。

>>> 

>>> 'foo'.ljust(2)
'foo'

s.lstrip([])

文字列から先頭の文字を切り取ります。

s.lstrip()は、左端から空白文字が削除されたsのコピーを返します。

>>> 

>>> '   foo bar baz   '.lstrip()
'foo bar baz   '
>>> '\t\nfoo\t\nbar\t\nbaz'.lstrip()
'foo\t\nbar\t\nbaz'

オプションの<chars>引数が指定されている場合、それは削除される文字のセットを指定する文字列です。

>>> 

>>> 'http://www.realpython.com'.lstrip('/:pth')
'www.realpython.com'

s.replace(, [, ])

文字列内の部分文字列の出現を置き換えます。

Pythonでは、文字列から文字を削除するには、Python文字列.replace()メソッドを使用できます。 s.replace(<old>, <new>)は、sのコピーを返し、部分文字列<old>のすべての出現が<new>に置き換えられます。

>>> 

>>> 'foo bar foo baz foo qux'.replace('foo', 'grault')
'grault bar grault baz grault qux'

オプションの<count>引数が指定されている場合、sの左端から開始して、最大<count>の置換が実行されます。

>>> 

>>> 'foo bar foo baz foo qux'.replace('foo', 'grault', 2)
'grault bar grault baz foo qux'

s.rjust([, ])

フィールド内の文字列を右揃えにします。

s.rjust(<width>)は、幅<width>のフィールドで右寄せされたsで構成される文字列を返します。 デフォルトでは、パディングはASCIIスペース文字で構成されます。

>>> 

>>> 'foo'.rjust(10)
'       foo'

オプションの<fill>引数が指定されている場合、それはパディング文字として使用されます。

>>> 

>>> 'foo'.rjust(10, '-')
'-------foo'

sがすでに少なくとも<width>と同じ長さである場合、変更されずに返されます。

>>> 

>>> 'foo'.rjust(2)
'foo'

s.rstrip([])

文字列から末尾の文字を削除します。

s.rstrip()は、右端から空白文字が削除されたsのコピーを返します。

>>> 

>>> '   foo bar baz   '.rstrip()
'   foo bar baz'
>>> 'foo\t\nbar\t\nbaz\t\n'.rstrip()
'foo\t\nbar\t\nbaz'

オプションの<chars>引数が指定されている場合、それは削除される文字のセットを指定する文字列です。

>>> 

>>> 'foo.$$$;'.rstrip(';$.')
'foo'

s.strip([])

文字列の左端と右端から文字を取り除きます。

s.strip()は、基本的にs.lstrip()とs.rstrip()を連続して呼び出すことと同じです。 <chars>引数がないと、先頭と末尾の空白が削除されます。

>>> 

>>> s = '   foo bar baz\t\t\t'
>>> s = s.lstrip()
>>> s = s.rstrip()
>>> s
'foo bar baz'

.lstrip()および.rstrip()と同様に、オプションの<chars>引数は、削除する文字のセットを指定します。

>>> 

>>> 'www.realpython.com'.strip('w.moc')
'realpython'

Note:文字列メソッドの戻り値が別の文字列である場合、よくあることですが、呼び出しを連鎖させることにより、メソッドを連続して呼び出すことができます。

>>> 

>>> '   foo bar baz\t\t\t'.lstrip().rstrip()
'foo bar baz'
>>> '   foo bar baz\t\t\t'.strip()
'foo bar baz'

>>> 'www.realpython.com'.lstrip('w.moc').rstrip('w.moc')
'realpython'
>>> 'www.realpython.com'.strip('w.moc')
'realpython'

s.zfill()

文字列の左側にゼロを埋め込みます。

s.zfill(<width>)は、'0'文字が左に埋め込まれたsのコピーを指定された<width>に返します。

>>> 

>>> '42'.zfill(5)
'00042'

sに先行記号が含まれている場合、ゼロが挿入された後も結果文字列の左端に残ります。

>>> 

>>> '+42'.zfill(8)
'+0000042'
>>> '-42'.zfill(8)
'-0000042'

sがすでに少なくとも<width>と同じ長さである場合、変更されずに返されます。

>>> 

>>> '-42'.zfill(3)
'-42'

.zfill()は数値の文字列表現に最も役立ちますが、Pythonはそれでも次のような文字列をゼロパディングします。

>>> 

>>> 'foo'.zfill(6)
'000foo'
文字列とリスト間の変換

このグループのメソッドは、オブジェクトを貼り付けて文字列を作成するか、文字列を断片に分割することにより、文字列と一部の複合データ型の間で変換します。

これらのメソッドは、オブジェクトのシーケンシャルコレクションの一般的なPython用語であるiterablesを操作するか、iterablesを返します。 イテレート可能オブジェクトの内部の仕組みについては、今後の明確な反復に関するチュートリアルで詳しく説明します。

これらのメソッドの多くは、リストまたはタプルを返します。 これらは、Pythonでのイテラブルの典型的な例である2つの類似した複合データ型です。 それらは次のチュートリアルでカバーされているので、すぐにそれらについて学びましょう！ それまでは、単に値のシーケンスと考えてください。 リストは角括弧（[]）で囲まれ、タプルは括弧（()）で囲まれます。

その紹介では、この最後の文字列メソッドのグループを見てみましょう。

s.join()

イテラブルから文字列を連結します。

s.join(<iterable>)は、sで区切られた<iterable>内のオブジェクトを連結した結果の文字列を返します。

.join()は、区切り文字列であるsで呼び出されることに注意してください。 <iterable>も文字列オブジェクトのシーケンスである必要があります。

いくつかのサンプルコードがわかりやすくなります。 次の例では、区切り文字sは文字列', 'であり、<iterable>は文字列値のリストです。

>>> 

>>> ', '.join(['foo', 'bar', 'baz', 'qux'])
'foo, bar, baz, qux'

結果は、コンマで区切られたリストオブジェクトで構成される単一の文字列です。

次の例では、<iterable>が単一の文字列値として指定されています。 文字列値が反復可能として使用される場合、文字列の個々の文字のリストとして解釈されます。

>>> 

>>> list('corge')
['c', 'o', 'r', 'g', 'e']

>>> ':'.join('corge')
'c:o:r:g:e'

したがって、':'.join('corge')の結果は、':'で区切られた'corge'の各文字で構成される文字列になります。

<iterable>のオブジェクトの1つが文字列ではないため、この例は失敗します。

>>> 

>>> '---'.join(['foo', 23, 'bar'])
Traceback (most recent call last):
  File "", line 1, in 
    '---'.join(['foo', 23, 'bar'])
TypeError: sequence item 1: expected str instance, int found

しかし、それは改善できます：

>>> 

>>> '---'.join(['foo', str(23), 'bar'])
'foo---23---bar'

すぐにわかるように、Pythonの多くの複合オブジェクトは反復可能であると解釈でき、.join()はそれらから文字列を作成するのに特に役立ちます。

s.partition()

区切り文字に基づいて文字列を分割します。

s.partition(<sep>)は、文字列<sep>の最初の出現時にsを分割します。 戻り値は、以下で構成される3つの部分からなるタプルです。

  • <sep>の前のsの部分

  • <sep>自体

  • <sep>に続くsの部分

動作中の.partition()の例をいくつか示します。

>>> 

>>> 'foo.bar'.partition('.')
('foo', '.', 'bar')
>>> 'foo@@bar@@baz'.partition('@@')
('foo', '@@', 'bar@@baz')

<sep>がsで見つからない場合、返されるタプルにはsとそれに続く2つの空の文字列が含まれます。

>>> 

>>> 'foo.bar'.partition('@@')
('foo.bar', '', '')

Remember:リストとタプルについては、次のチュートリアルで説明します。

s.rpartition()

区切り文字に基づいて文字列を分割します。

s.rpartition(<sep>)はs.partition(<sep>)とまったく同じように機能しますが、sは最初の出現ではなく最後の出現で分割される点が異なります。

>>> 

>>> 'foo@@bar@@baz'.partition('@@')
('foo', '@@', 'bar@@baz')

>>> 'foo@@bar@@baz'.rpartition('@@')
('foo@@bar', '@@', 'baz')

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

文字列を部分文字列のリストに分割します。

引数がない場合、s.rsplit()はsを空白のシーケンスで区切られた部分文字列に分割し、部分文字列をリストとして返します。

>>> 

>>> 'foo bar baz qux'.rsplit()
['foo', 'bar', 'baz', 'qux']
>>> 'foo\n\tbar   baz\r\fqux'.rsplit()
['foo', 'bar', 'baz', 'qux']

<sep>が指定されている場合、分割の区切り文字として使用されます。

>>> 

>>> 'foo.bar.baz.qux'.rsplit(sep='.')
['foo', 'bar', 'baz', 'qux']

（<sep>がNoneの値で指定されている場合、<sep>がまったく指定されていないかのように、文字列は空白で区切られて分割されます。）

<sep>が区切り文字として明示的に指定されている場合、s内の連続する区切り文字は、空の文字列を区切ると見なされ、次のように返されます。

>>> 

>>> 'foo...bar'.rsplit(sep='.')
['foo', '', '', 'bar']

ただし、<sep>が省略されている場合はそうではありません。 その場合、連続する空白文字が単一の区切り文字に結合され、結果のリストに空の文字列が含まれることはありません。

>>> 

>>> 'foo\t\t\tbar'.rsplit()
['foo', 'bar']

オプションのキーワードパラメータ<maxsplit>が指定されている場合、sの右端から開始して、最大でその数の分割が実行されます。

>>> 

>>> 'www.realpython.com'.rsplit(sep='.', maxsplit=1)
['www.realpython', 'com']

<maxsplit>のデフォルト値は-1です。これは、<maxsplit>が完全に省略されている場合と同じように、可能なすべての分割を実行する必要があることを意味します。

>>> 

>>> 'www.realpython.com'.rsplit(sep='.', maxsplit=-1)
['www', 'realpython', 'com']
>>> 'www.realpython.com'.rsplit(sep='.')
['www', 'realpython', 'com']

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

文字列を部分文字列のリストに分割します。

s.split()はs.rsplit()とまったく同じように動作しますが、<maxsplit>が指定されている場合、分割はsの右端ではなく左端からカウントされます。

>>> 

>>> 'www.realpython.com'.split('.', maxsplit=1)
['www', 'realpython.com']
>>> 'www.realpython.com'.rsplit('.', maxsplit=1)
['www.realpython', 'com']

<maxsplit>が指定されていない場合、.split()と.rsplit()は区別できません。

s.splitlines([])

行の境界で文字列を区切ります。

s.splitlines()は、sを行に分割し、リストに返します。 次の文字または文字シーケンスのいずれかが行境界を構成すると見なされます。

エスケープシーケンス キャラクター

\n

改行

\r

キャリッジリターン

\r\n

キャリッジリターン+ラインフィード

または

ライン集計

または

フォームフィード

\x1c

ファイル区切り文字

\x1d

グループセパレーター

\x1e

レコード区切り文字

\x85

次の行（C1制御コード）

\u2028

Unicode行区切り文字

\u2029

Unicode段落区切り文字

次に、いくつかの異なる行区切り記号を使用した例を示します。

>>> 

>>> 'foo\nbar\r\nbaz\fqux\u2028quux'.splitlines()
['foo', 'bar', 'baz', 'qux', 'quux']

連続する行境界文字が文字列に存在する場合、空行を区切るとみなされ、結果リストに表示されます。

>>> 

>>> 'foo\f\f\fbar'.splitlines()
['foo', '', '', 'bar']

オプションの<keepends>引数が指定されていて、それが真である場合、行の境界は結果文字列に保持されます。

>>> 

>>> 'foo\nbar\nbaz\nqux'.splitlines(True)
['foo\n', 'bar\n', 'baz\n', 'qux']
>>> 'foo\nbar\nbaz\nqux'.splitlines(1)
['foo\n', 'bar\n', 'baz\n', 'qux']

bytesオブジェクト

bytesオブジェクトは、バイナリデータを操作するためのコア組み込み型の1つです。 bytesオブジェクトは、単一のbyte値の不変のシーケンスです。 bytesオブジェクトの各要素は、0から255の範囲の小さな整数です。

リテラルbytesオブジェクトの定義

bytesリテラルは、文字列リテラルと同じ方法で定義されますが、'b'プレフィックスが追加されます。

>>> 

>>> b = b'foo bar baz'
>>> b
b'foo bar baz'
>>> type(b)

文字列と同様に、シングル、ダブル、トリプルのいずれかのクォートメカニズムを使用できます。

>>> 

>>> b'Contains embedded "double" quotes'
b'Contains embedded "double" quotes'

>>> b"Contains embedded 'single' quotes"
b"Contains embedded 'single' quotes"

>>> b'''Contains embedded "double" and 'single' quotes'''
b'Contains embedded "double" and \'single\' quotes'

>>> b"""Contains embedded "double" and 'single' quotes"""
b'Contains embedded "double" and \'single\' quotes'

bytesリテラルではASCII文字のみが許可されます。 127より大きい文字値は、適切なエスケープシーケンスを使用して指定する必要があります。

>>> 

>>> b = b'foo\xddbar'
>>> b
b'foo\xddbar'
>>> b[3]
221
>>> int(0xdd)
221

'r'プレフィックスは、文字列の場合と同様に、エスケープシーケンスの処理を無効にするためにbytesリテラルで使用できます。

>>> 

>>> b = rb'foo\xddbar'
>>> b
b'foo\\xddbar'
>>> b[3]
92
>>> chr(92)
'\\'

組み込みのbytes()関数を使用したbytesオブジェクトの定義

bytes()関数は、bytesオブジェクトも作成します。 どのような種類のbytesオブジェクトが返されるかは、関数に渡される引数によって異なります。 可能な形式を以下に示します。

bytes(, )

文字列からbytesオブジェクトを作成します。

bytes(<s>, <encoding>)は、指定された<encoding>に従ってstr.encode()を使用して、文字列<s>をbytesオブジェクトに変換します。

>>> 

>>> b = bytes('foo.bar', 'utf8')
>>> b
b'foo.bar'
>>> type(b)

Technical Note:この形式のbytes()関数では、<encoding>引数が必要です。 「エンコーディング」とは、文字が整数値に変換される方法を指します。 "utf8"の値は、Unicode変換形式UTF-8を示します。これは、可能なすべてのUnicode文字を処理できるエンコーディングです。 UTF-8は、<encoding>に"UTF8"、"utf-8"、または"UTF-8"を指定して示すこともできます。

詳細については、Unicode documentationを参照してください。 一般的なラテン語ベースの文字を扱っている限り、UTF-8で十分です。

bytes()

null（0x00）バイトで構成されるbytesオブジェクトを作成します。

bytes(<size>)は、指定された<size>のbytesオブジェクトを定義します。これは、正の整数である必要があります。 結果のbytesオブジェクトはnull（0x00）バイトに初期化されます。

>>> 

>>> b = bytes(8)
>>> b
b'\x00\x00\x00\x00\x00\x00\x00\x00'
>>> type(b)

bytes()

iterableからbytesオブジェクトを作成します。

bytes(<iterable>)は、<iterable>によって生成された整数のシーケンスからbytesオブジェクトを定義します。 <iterable>は、0 ≤ n ≤ 255の範囲の整数nのシーケンスを生成する反復可能である必要があります。

>>> 

>>> b = bytes([100, 102, 104, 106, 108])
>>> b
b'dfhjl'
>>> type(b)

>>> b[2]
104

bytesオブジェクトの操作

文字列と同様に、bytesオブジェクトは一般的なシーケンス操作をサポートします。

  • inおよびnot in演算子：

    >>> 

>>> b = b'abcde'

>>> b'cd' in b
True
>>> b'foo' not in b
True

  • 連結（+）および複製（*）演算子：

    >>> 

>>> b = b'abcde'

>>> b + b'fghi'
b'abcdefghi'
>>> b * 3
b'abcdeabcdeabcde'

  • インデックス付けとスライス：

    >>> 

>>> b = b'abcde'

>>> b[2]
99
>>> b[1:3]
b'bc'

  • 組み込み関数：

    >>> 

>>> len(b)
5
>>> min(b)
97
>>> max(b)
101

文字列オブジェクトに対して定義されたメソッドの多くは、bytesオブジェクトに対しても有効です。

>>> 

>>> b = b'foo,bar,foo,baz,foo,qux'

>>> b.count(b'foo')
3

>>> b.endswith(b'qux')
True

>>> b.find(b'baz')
12

>>> b.split(sep=b',')
[b'foo', b'bar', b'foo', b'baz', b'foo', b'qux']

>>> b.center(30, b'-')
b'---foo,bar,foo,baz,foo,qux----'

ただし、これらの演算子とメソッドがbytesオブジェクトで呼び出される場合、オペランドと引数もbytesオブジェクトである必要があることに注意してください。

>>> 

>>> b = b'foo.bar'

>>> b + '.baz'
Traceback (most recent call last):
  File "", line 1, in 
    b + '.baz'
TypeError: can't concat bytes to str
>>> b + b'.baz'
b'foo.bar.baz'

>>> b.split(sep='.')
Traceback (most recent call last):
  File "", line 1, in 
    b.split(sep='.')
TypeError: a bytes-like object is required, not 'str'
>>> b.split(sep=b'.')
[b'foo', b'bar']

bytesオブジェクトの定義と表現はASCIIテキストに基づいていますが、実際には、0から255までの範囲の小さな整数の不変シーケンスのように動作します。 これが、bytesオブジェクトの単一の要素が整数として表示される理由です。

>>> 

>>> b = b'foo\xddbar'
>>> b[3]
221
>>> hex(b[3])
'0xdd'
>>> min(b)
97
>>> max(b)
221

ただし、スライスの長さが1バイトしかない場合でも、スライスはbytesオブジェクトとして表示されます。

>>> 

>>> b[2:3]
b'c'

組み込みのlist()関数を使用して、bytesオブジェクトを整数のリストに変換できます。

>>> 

>>> list(b)
[97, 98, 99, 100, 101]

2進数の16進数は1バイトに直接対応するため、16進数がバイナリデータの指定によく使用されます。 bytesクラスは、16進数の文字列との間の変換を容易にする2つの追加メソッドをサポートします。

bytes.fromhex()

16進値の文字列から構築されたbytesオブジェクトを返します。

bytes.fromhex(<s>)は、<s>の16進数の各ペアを対応するバイト値に変換した結果のbytesオブジェクトを返します。 <s>の16進数のペアは、オプションで空白で区切ることができますが、無視されます。

>>> 

>>> b = bytes.fromhex(' aa 68 4682cc ')
>>> b
b'\xaahF\x82\xcc'
>>> list(b)
[170, 104, 70, 130, 204]

Note:このメソッドはクラスメソッドであり、オブジェクトメソッドではありません。 bytesオブジェクトではなく、bytesクラスにバインドされます。 object-oriented programmingに関する今後のチュートリアルでは、クラス、オブジェクト、およびそれぞれのメソッドの違いについてさらに詳しく説明します。 今のところ、このメソッドはオブジェクトbではなく、bytesクラスで呼び出されることに注意してください。

b.hex()

bytesオブジェクトから16進値の文字列を返します。

b.hex()は、bytesオブジェクトbを16進数のペアの文字列に変換した結果を返します。 つまり、.fromhex()の逆を実行します。

>>> 

>>> b = bytes.fromhex(' aa 68 4682cc ')
>>> b
b'\xaahF\x82\xcc'

>>> b.hex()
'aa684682cc'
>>> type(b.hex())

Note:.fromhex()とは対照的に、.hex()はオブジェクトメソッドであり、クラスメソッドではありません。 したがって、クラス自体ではなく、bytesクラスのオブジェクトで呼び出されます。

bytearrayオブジェクト

Pythonは、bytearrayと呼ばれる別のバイナリシーケンスタイプをサポートしています。 bytearrayオブジェクトは、いくつかの違いはありますが、bytesオブジェクトと非常によく似ています。

  • bytesオブジェクトを定義するために使用できる'b'プレフィックスのように、bytearrayリテラルを定義するための専用の構文はPythonに組み込まれていません。 bytearrayオブジェクトは、常にbytearray()組み込み関数を使用して作成されます。

    >>> 

>>> ba = bytearray('foo.bar.baz', 'UTF-8')
>>> ba
bytearray(b'foo.bar.baz')

>>> bytearray(6)
bytearray(b'\x00\x00\x00\x00\x00\x00')

>>> bytearray([100, 102, 104, 106, 108])
bytearray(b'dfhjl')

  • bytearrayオブジェクトは変更可能です。 インデックス作成とスライスを使用して、bytearrayオブジェクトの内容を変更できます。

    >>> 

>>> ba = bytearray('foo.bar.baz', 'UTF-8')
>>> ba
bytearray(b'foo.bar.baz')

>>> ba[5] = 0xee
>>> ba
bytearray(b'foo.b\xeer.baz')

>>> ba[8:11] = b'qux'
>>> ba
bytearray(b'foo.b\xeer.qux')

bytearrayオブジェクトは、bytesオブジェクトから直接構築することもできます。

>>> 

>>> ba = bytearray(b'foo')
>>> ba
bytearray(b'foo')

結論

このチュートリアルでは、文字列演算子、組み込み関数、インデックス作成、スライス、組み込みメソッドなど、Pythonがstringの処理に提供するさまざまなメカニズムについて詳しく説明しました。 また、bytesおよびbytearrayタイプについても紹介しました。

これらのタイプは、小さなパーツのコレクションから構築された複合的な最初のタイプです。 Pythonは、いくつかの複合組み込み型を提供します。 次のチュートリアルでは、最も頻繁に使用される2つのlistsとtuplesについて説明します。

__ Take the Quiz:インタラクティブな「Python文字列と文字データ」クイズで知識をテストします。 完了すると、学習の進捗状況を経時的に追跡できるようにスコアを受け取ります。

クイズに答える»

Related