TOC

Pythonの文字列と文字データ

Pythonの文字列と文字データ

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

このチュートリアルで学習する内容は次のとおりです。 Pythonには、文字列を操作するための豊富な演算子、関数、およびメソッドのセットが用意されています。 このチュートリアルを終了すると、文字列の一部にアクセスして抽出する方法がわかります。また、文字列データを操作および変更するために使用できるメソッドについても理解できます。

また、未処理のバイトデータを表すために使用される2つのPythonオブジェクト、 `+ bytes `および ` bytearray +`タイプについても紹介します。

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

link：/quizzes/python-strings/[クイズに挑戦»]

文字列操作

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

文字列演算子

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

組み込みの文字列関数

Pythonの基本データ型のチュートリアルで見たように、Pythonはインタープリターに組み込まれ、常に利用可能な多くの関数を提供します。 文字列を扱ういくつかの例を次に示します。

Function Description

chr()

Converts an integer to a character

ord()

Converts a character to an integer

len()

Returns the length of a string

str()

Returns a string representation of an object

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

+ ord（c）+

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

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

一般的に使用される最も単純なスキームは、https://en.wikipedia.org/wiki/ASCII [ASCII]と呼ばれます。 おそらく最もよく使い慣れている一般的なラテン文字を網羅しています。 これらの文字について、 `+ ord（c）`は文字 ` c +`のASCII値を返します。

>>>

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

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

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

詳細情報： Pythonドキュメントのhttps://docs.python.org/3/howto/unicode.html#python-s-unicode-support[PythonのUnicodeサポート]を参照してください。

一般的な文字の領域にいる限り、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 "<pyshell#17>", line 1, in <module>
    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 "<pyshell#26>", line 1, in <module>
    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'

*注意：*文字列インデックスはゼロベースです。 文字列の最初の文字のインデックスは「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の記事https://realpython.com/python-f-strings/[Python 3のf-Strings：改良された文字列フォーマット構文（ガイド）]をご覧ください。 このシリーズの後半で、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 "<pyshell#40>", line 1, in <module>
    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'

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

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

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

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

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

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

obj.foo(<args>)

これにより、オブジェクト `+ 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（<sub> [、<start> [、<end>]]）+

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

`+ s.count（<sub>）`は、 ` s `のサブストリング ` <sub> +`の重複しない出現回数を返します。

>>>

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

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

>>>

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

+ s.endswith（<suffix> [、<start> [、<end>]]）+

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

`+ s.endswith（<suffix>）`は、指定された ` <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（<sub> [、<start> [、<end>]]）+

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

`+ .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（<sub> [、<start> [、<end>]]）+

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

このメソッドは、 `+ .find（）`と同じですが、 ` -1 `を返すのではなく、 ` <sub> +`が見つからない場合に例外を発生させる点が異なります。

>>>

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

+ s.rfind（<sub> [、<start> [、<end>]]）+

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

`+ 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（<sub> [、<start> [、<end>]]）+

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

このメソッドは `+ .rfind（）`と同じですが、 ` -1 `を返すのではなく、 ` <sub> +`が見つからない場合に例外を発生させる点が異なります。

>>>

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

+ s.startswith（<prefix> [、<start> [、<end>]]）+

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

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

注意： `+ .isidentifier（）`は、実際には有効な識別子ではない場合でも、Pythonキーワードに一致する文字列に対して ` True +`を返します。

>>>

>>> 'and'.isidentifier()
True

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

>>>

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

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

Pythonモジュールの詳細については、https://realpython.com/python-modules-packages/[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

*注意：*これは、 `+ s `が空の文字列の場合に ` True `を返す唯一の ` .isxxxx（）`メソッドです。 他のすべては空の文字列に対して ` False +`を返します。

+ s.isspace（）+

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

`+ s.isspace（）`は、 ` s `が空でなく、すべての文字が空白文字である場合は ` True `を返し、そうでない場合は ` False +`を返します。

最も一般的な空白文字は、スペース「」「」、タブ「」\ t ' `、および改行「+」\ n' +`です。

>>>

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

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

>>>

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

（ `+ '\ f' `および ` '\ r' `はASCIIフォームフィードおよびキャリッジリターン文字のエスケープシーケンスです; ` '\ u2005' +`はUnicode Four-Perのエスケープシーケンスです-スペース。

+ s.istitle（）+

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

`+ s.istitle（）`は、 ` s `が空でなく、各単語の最初のアルファベット文字が大文字で、各単語の他のすべてのアルファベット文字が小文字の場合、 ` True `を返します。 そうでなければ、 ` False +`を返します：

>>>

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

注意： Pythonのドキュメントでは、「。istitle（）」についてよりわかりやすく説明しています。「大文字は大文字と小文字を区別せず、小文字は大文字と小文字を区別できます。」

+ s.isupper（）+

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

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

>>>

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

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

+ s.center（<width> [、<fill>]）+

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

`+ 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（）+`は各タブ文字（ `+ '\ t' +）をスペースに置き換えます。 デフォルトでは、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（<width> [、<fill>]）+

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

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

>>>

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

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

>>>

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

`+ s `が少なくとも ` <width> +`と同じ長さの場合、変更されずに返されます：

>>>

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

+ s.lstrip（[<chars>]）+

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

`+ 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（<old>、<new> [、<count>]）+

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

Pythonでは、文字列から文字を削除するには、Python文字列の `+ .replace（）`メソッドを使用できます。 ` s.replace（<old>、<new>）`は、サブストリング ` <old> `のすべての出現を ` <new> `で置き換えた ` s +`のコピーを返します。

>>>

>>> '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（<width> [、<fill>]）+

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

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

>>>

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

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

>>>

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

`+ s `が少なくとも ` <width> +`と同じ長さの場合、変更されずに返されます：

>>>

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

+ s.rstrip（[<chars>]）+

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

`+ 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（[<chars>]）+

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

`+ 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'

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

>>>

>>> '   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（<width>）+

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

`+ s.zfill（<width>）`は、指定された ` <width> `に ` '0' `文字を左詰めした ` s +`のコピーを返します。

>>>

>>> '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 を操作するか、返します。 イテレート可能オブジェクトの内部の仕組みについては、今後の明確な反復に関するチュートリアルで詳しく説明します。

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

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

+ s.join（<iterable>）+

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

`+ 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 "<pyshell#0>", line 1, in <module>
    '---'.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（<sep>）+

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

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

  • `+ <sep> `の前の ` s +`の部分

  • `+ <sep> +`自体

  • `+ <sep> `に続く ` s +`の部分

動作中の `+ .partition（）+`の例をいくつか示します。

>>>

>>> 'foo.bar'.partition('.')
('foo', '.', 'bar')
>>> '[email protected]@[email protected]@baz'.partition('@@')
('foo', '@@', '[email protected]@baz')

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

>>>

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

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

+ s.rpartition（<sep>）+

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

`+ s.rpartition（<sep>）`は ` s.partition（<sep>）`とまったく同じように機能しますが、 ` s `は ` <sep> +`の最後ではなく、最初の出現：

>>>

>>> '[email protected]@[email protected]@baz'.partition('@@')
('foo', '@@', '[email protected]@baz')

>>> '[email protected]@[email protected]@baz'.rpartition('@@')
('[email protected]@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 」ではなく「 s +右端：

>>>

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

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

+ s.splitlines（[<keepends>]）+

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

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

Escape Sequence Character

\n

Newline

\r

Carriage Return

\r\n

Carriage Return + Line Feed

\v or \x0b

Line Tabulation

\f or \x0c

Form Feed

\x1c

File Separator

\x1d

Group Separator

\x1e

Record Separator

\x85

Next Line (C1 Control Code)

\u2028

Unicode Line Separator

\u2029

Unicode Paragraph Separator

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

>>>

>>> '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 `オブジェクトは、単一のhttps://en.wikipedia.org/wiki/Byte[byte]値の不変のシーケンスです。 ` bytes `オブジェクトの各要素は、 ` 0 `から ` 255 +`の範囲の小さな整数です。

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

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

>>>

>>> b = b'foo bar baz'
>>> b
b'foo bar baz'
>>> type(b)
<class 'bytes'>

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

>>>

>>> 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（<s>、<encoding>）+

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

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

>>>

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

テクニカルノート：*この形式の + bytes（）+`関数では、 `+ <encoding> +`引数が必要です。 「エンコーディング」とは、文字が整数値に変換される方法を指します。 `+" utf8 "+`の値は、Unicode Transformation Format *UTF-8 を示します。これは、可能なすべてのUnicode文字を処理できるエンコードです。 UTF-8は、 `+ <encoding> +`に対して `+" UTF8 "+

Related