Python Language
文字列メソッド

構文

• str.capitalize（） - > str
• str.casefold（） - > str [Python> 3.3のみ]
• str.center（width [、fillchar]） - > str
• str.count（sub [、start [、end]]） - > int
• str.decode（encoding = "utf-8" [、errors]） - > unicode [Python 2.xのみ]
• str.encode（encoding = "utf-8"、errors = "strict"） - >バイト
• str.endswith（接尾辞[、start [、end]]） - > bool
• str.expandtabs（tabsize = 8） - > str
• str.find（sub [、start [、end]]） - > int
• str.format（* args、** kwargs） - > str
• str.format_map（マッピング） - > str
• str.index（sub [、start [、end]]） - > int
• str.isalnum（） - > bool
• str.isalpha（） - > bool
• str.isdecimal（） - > bool
• str.isdigit（） - > bool
• str.isidentifier（） - > bool
• str.islower（） - > bool
• str.isnumeric（） - > bool
• str.isprintable（） - > bool
• str.isspace（） - > bool
• str.istitle（） - > bool
• str.isupper（） - > bool
• str.join（iterable） - > str
• str.ljust（width [、fillchar]） - > str
• str.lower（） - > str
• str.lstrip（[chars]） - > str
• static str.maketrans（x [、y [、z]]）
• str.partition（sep） - >（head、sep、tail）
• str.replace（old、new [、count]） - > str
• str.rfind（sub [、start [、end]]） - > int
• str.rindex（sub [、start [、end]]） - > int
• str.rjust（width [、fillchar]） - > str
• str.rpartition（sep） - >（head、sep、tail）
• str.rsplit（sep = None、maxsplit = -1） - >文字列のリスト
• str.rstrip（[chars]） - > str
• str.split（sep = None、maxsplit = -1） - >文字列のリスト
• str.splitlines（[keepends]） - >文字列のリスト
• str.startswith（接頭辞[、start [、end]]） - >本
• str.strip（[chars]） - > str
• str.swapcase（） - > str
• str.title（） - > str
• str.translate（table） - > str
• str.upper（） - > str
• str.zfill（width） - > str

備考

文字列の大文字と小文字の変更

Pythonの文字列型は、文字列の大文字化に作用する多くの関数を提供します。これらには、

• str.casefold
• str.upper
• str.lower
• str.capitalize
• str.title
• str.swapcase

Unicode文字列（Python 3のデフォルト）では、これらの操作は1：1マッピングでも可逆でもありません 。これらの操作のほとんどは、正規化ではなく、表示のためのものです。

"XßΣ".casefold()
# 'xssσ'

"XßΣ".lower()
# 'xßς'

str.upper()

str.upperは文字列内のすべての文字を取り、それを大文字に変換します。例：

"This is a 'string'.".upper()
# "THIS IS A 'STRING'."

str.lower()

str.lowerは反対です。文字列内のすべての文字を取り、小文字に変換します。

"This IS a 'string'.".lower()
# "this is a 'string'."

str.capitalize()

str.capitalizeは大文字の文字列を返します。つまり、最初の文字は大文字にし、残りの文字は低くします。

"this Is A 'String'.".capitalize() # Capitalizes the first character and lowercases all others
# "This is a 'string'."

str.title()

str.titleは、文字列のタイトルにstr.titleバージョンを返します。つまり、単語の先頭にあるすべての文字は大文字になり、それ以外はすべて小文字になります。

"this Is a 'String'".title()
# "This Is A 'String'"

str.swapcase()

str.swapcaseは、すべての小文字が大文字にスワップされ、すべて大文字が下にスワップされる新しい文字列オブジェクトを返します。

"this iS A STRiNG".swapcase() #Swaps case of each character
# "THIS Is a strIng"

strクラスメソッドとしての使用法

これらのメソッドは、文字列オブジェクト（上記のように）またはstrクラスのクラスメソッド（ str.upperへの明示的な呼び出しなど）で呼び出すことがstr.upper 。

str.upper("This is a 'string'")
# "THIS IS A 'STRING'"

これは、これらのメソッドの1つを多くの文字列に一度にmap関数で適用するときに最も便利です。

map(str.upper,["These","are","some","'strings'"])
# ['THESE', 'ARE', 'SOME', "'STRINGS'"]

区切り文字に基づいて文字列を文字列のリストに分割する

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

str.splitは文字列を受け取り、元の文字列の部分文字列のリストを返します。動作は、 sep引数が指定されているか省略されているかによって異なります。

sepが指定されていない場合、またはNoneが指定されている場合は、空白がある場所であれば分割が行われます。しかし、先頭と末尾の空白は無視され、複数の連続した空白文字は1つの空白文字と同じように扱われます。

>>> "This is a sentence.".split()
['This', 'is', 'a', 'sentence.']

>>> " This is    a sentence.  ".split()
['This', 'is', 'a', 'sentence.']

>>> "            ".split()
[]

sepパラメータは、区切り文字列を定義するために使用できます。元の文字列は、区切り文字列があるところで分割され、区切り文字自体は破棄されます。複数の連続する区切り文字は、単一のオカレンスと同じように扱われるのではなく 、むしろ空の文字列が作成されます。

>>> "This is a sentence.".split(' ')
['This', 'is', 'a', 'sentence.']

>>> "Earth,Stars,Sun,Moon".split(',')
['Earth', 'Stars', 'Sun', 'Moon']

>>> " This is    a sentence.  ".split(' ')
['', 'This', 'is', '', '', '', 'a', 'sentence.', '', '']

>>> "This is a sentence.".split('e')
['This is a s', 'nt', 'nc', '.']

>>> "This is a sentence.".split('en')
['This is a s', 't', 'ce.']

デフォルトでは、デリミタが出現するたびに分割されますが、 maxsplitパラメータは発生する分割数を制限します。デフォルト値-1は無制限を意味します：

>>> "This is a sentence.".split('e', maxsplit=0)
['This is a sentence.']

>>> "This is a sentence.".split('e', maxsplit=1)
['This is a s', 'ntence.']

>>> "This is a sentence.".split('e', maxsplit=2)
['This is a s', 'nt', 'nce.']

>>> "This is a sentence.".split('e', maxsplit=-1)
['This is a s', 'nt', 'nc', '.']

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

str.rsplit （「権利スプリット」）とは異なるstr.splitとき（「左スプリット」） maxsplit指定されています。分割は、最初ではなく文字列の最後から開始されます。

>>> "This is a sentence.".rsplit('e', maxsplit=1)
['This is a sentenc', '.']

>>> "This is a sentence.".rsplit('e', maxsplit=2)
['This is a sent', 'nc', '.']

注 ：Pythonは実行される分割の最大数を指定しますが、他のほとんどのプログラミング言語は作成される部分文字列の最大数を指定します。これは、コードを移植または比較するときに混乱を招く可能性があります。

ある部分文字列のすべての出現箇所を別の部分文字列に置き換える

Pythonのstr型には、あるサブ文字列の出現箇所を、指定された文字列内の別のサブ文字列に置き換えるメソッドもあります。より要求の厳しい場合には、 re.sub

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

str.replaceは、 newサブ文字列で置き換えられるoldサブ文字列を含むoldとnew 2つの引数をとります。オプションの引数countは、置き換えのcount指定します。

たとえば、次の文字列で'foo'を'spam'にstr.replace 、 old = 'foo'とnew = 'spam' str.replaceを呼び出すことができます。

>>> "Make sure to foo your sentence.".replace('foo', 'spam')
"Make sure to spam your sentence."

指定された文字列にold引数と一致する複数の例が含まれている場合、 すべての文字列はnew指定された値に置き換えられます。

>>> "It can foo multiple examples of foo if you want.".replace('foo', 'spam')
"It can spam multiple examples of spam if you want."

もちろん、 count値を指定しない限りこの場合、 countオカレンスは置き換えられます：

>>> """It can foo multiple examples of foo if you want, \
... or you can limit the foo with the third argument.""".replace('foo', 'spam', 1)
'It can spam multiple examples of foo if you want, or you can limit the foo with the third argument.'

str.formatとf-strings：値を文字列にフォーマットする

Pythonは、バージョン2.6で導入されたstr.format関数とバージョン3.6で導入されたf-stringsによって、文字列の補間と書式設定機能を提供します。

次の変数が与えられた場合：

i = 10
f = 1.5
s = "foo"
l = ['a', 1, 2]
d = {'a': 1, 2: 'foo'}

次の文はすべて同等です

"10 1.5 foo ['a', 1, 2] {'a': 1, 2: 'foo'}"

>>> "{} {} {} {} {}".format(i, f, s, l, d)

>>> str.format("{} {} {} {} {}", i, f, s, l, d)

>>> "{0} {1} {2} {3} {4}".format(i, f, s, l, d)

>>> "{0:d} {1:0.1f} {2} {3!r} {4!r}".format(i, f, s, l, d)

>>> "{i:d} {f:0.1f} {s} {l!r} {d!r}".format(i=i, f=f, s=s, l=l, d=d)

>>> f"{i} {f} {s} {l} {d}"

>>> f"{i:d} {f:0.1f} {s} {l!r} {d!r}"

参考までに、Pythonは文字列フォーマットのCスタイルの修飾子もサポートしています。以下の例は上記とstr.formatですが、柔軟性、表記の一貫性、拡張性という利点から、 str.formatバージョンが優先されます。

"%d %0.1f %s %r %r" % (i, f, s, l, d)

"%(i)d %(f)0.1f %(s)s %(l)r %(d)r" % dict(i=i, f=f, s=s, l=l, d=d)

str.format補間に使用する中括弧は、文字列の書式設定時に重複を減らすために番号をstr.formatこともできます。たとえば、以下は同等です。

"I am from Australia. I love cupcakes from Australia!"

>>> "I am from {}. I love cupcakes from {}!".format("Australia", "Australia")

>>> "I am from {0}. I love cupcakes from {0}!".format("Australia")

公式のpythonのドキュメントは、いつものように、徹底的に徹底していますが、 pyformat.infoには詳細な説明を含む素晴らしい例があります。

さらに、 {と}文字は二重括弧でエスケープできます。

"{'a': 5, 'b': 6}"

>>> "{{'{}': {}, '{}': {}}}".format("a", 5, "b", 6)

>>> f"{{'{'a'}': {5}, '{'b'}': {6}}"

詳細は、「 文字列フォーマット 」を参照してください。 str.format()はPEP 3101で提案され、f-stringsはPEP 498で提案されました。

文字列に部分文字列が現れる回数を数える

別の文字列str.countサブ文字列の出現回数をカウントする1つの方法があります。

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

str.countは、別の文字列内のsub文字列sub重複していないオカレンスの数を示すintを返します。オプションの引数startとendは検索のstartとend示します。デフォルトでstart = 0とend = len(str)は、文字列全体が検索されることを意味しend = len(str) 。

>>> s = "She sells seashells by the seashore."
>>> s.count("sh")
2
>>> s.count("se")
3
>>> s.count("sea")
2
>>> s.count("seashells")
1

別の値を指定することでstart 、 end我々はより局所的な検索を得ることができるとあれば、例えば、カウントstartに等しい13への呼び出し：

>>> s.count("sea", start)
1

次のものと同等です。

>>> t = s[start:]
>>> t.count("sea")
1

文字列の開始文字と終了文字をテストする

Pythonで与えられた文字列の始めと終わりをテストするために、 str.startswith()とstr.endswith()メソッドを使うことができます。

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

名前が意味するように、 str.startswithは、指定された文字列がprefix内の指定された文字で始まるかどうかをテストするために使用されprefix 。

>>> s = "This is a test string"
>>> s.startswith("T")
True
>>> s.startswith("Thi")
True
>>> s.startswith("thi")  
False

オプションの引数startとendは、テストの開始と終了の開始点と終了点を指定します。次の例では、開始値2指定することによって、文字列が位置2から検索されます。

>>> s.startswith("is", 2)
True

これは、 s[2] == 'i'とs[3] == 's' True s[3] == 's'ます。

tupleを使用して、文字列のセットで始まるかどうかを調べることもできます

>>> s.startswith(('This', 'That'))
True
>>> s.startswith(('ab', 'bc'))
False

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

str.endswithはstr.endswithとまったく同じstr.startswithが、唯一の違いは終了文字を検索し、開始文字は検索しないことです。たとえば、文字列が完全停止して終了するかどうかをテストするには、次のように記述します。

>>> s = "this ends in a full stop."
>>> s.endswith('.')
True
>>> s.endswith('!')
False

startswithとstartswithに、複数の文字を終了シーケンスとして使用できます。

>>> s.endswith('stop.')
True
>>> s.endswith('Stop.')
False

tupleを使用して、文字列のセットで終わるかどうかを調べることもできます

>>> s.endswith(('.', 'something'))
True
>>> s.endswith(('ab', 'bc'))
False

文字列の構成をテストする

Pythonのstr型には、文字列の内容を評価するために使用できるいくつかのメソッドもあります。これらはstr.isalpha 、 str.isdigit 、 str.isalnum 、 str.isspaceです。大文字とstr.isupper 、 str.islower 、 str.islower 、およびstr.istitleでテストできます。

str.isalpha

str.isalphaは引数を取りません。また、指定された文字列のすべての文字がアルファベットの場合はTrueを返します。

>>> "Hello World".isalpha()  # contains a space
False
>>> "Hello2World".isalpha()  # contains a number
False
>>> "HelloWorld!".isalpha()  # contains punctuation
False
>>> "HelloWorld".isalpha()
True

端の場合、空の文字列は"".isalpha()使用するとFalseに評価されます。

str.isupper 、 str.islower 、 str.istitle

これらのメソッドは、指定された文字列の大文字をテストします。

str.isupperは、指定された文字列のすべての文字が大文字の場合はTrueを返し、そうでない場合はFalseを返すメソッドです。

>>> "HeLLO WORLD".isupper()
False
>>> "HELLO WORLD".isupper()
True
>>> "".isupper()
False

逆に、 str.islowerは、指定された文字列のすべての文字が小文字であればTrueを返し、それ以外の場合はFalseを返すメソッドです。

>>> "Hello world".islower()
False
>>> "hello world".islower()
True
>>> "".islower()
False

str.istitleは、指定された文字列がタイトルに含まれる場合はTrue返します。つまり、すべての単語は大文字で始まり、その後に小文字が続きます。

>>> "hello world".istitle()
False
>>> "Hello world".istitle()
False
>>> "Hello World".istitle()
True
>>> "".istitle()
False

str.isdecimal 、 str.isdigit 、 str.isnumeric

str.isdecimalは、文字列が10進数のシーケンスであるかどうかを返します。これは10進数を表すのに適しています。

str.isdigitは、上付き数字などの小数を表すのに適していない数字が含まれます。

str.isnumericは、0〜9の範囲外の値など、数字でなくても任意の数値が含まれます。

            isdecimal    isdigit   isnumeric

12345        True        True       True
១2߃໔5        True        True       True
①²³🄅₅       False       True       True
⑩⒓          False       False      True
Five         False       False      False

Bytestrings（Python 3のbytes 、Python 2のstr ）は、 isdigitのみをサポートし、基本的なASCII数字のチェックのみを行います。

str.isalpha同様に、空文字列はFalse評価されます。

str.isalnum

これはstr.isalphaとstr.isnumeric組み合わせです。具体的には、指定された文字列のすべての文字が英数字である場合、つまり英字または数字で構成されている場合にTrueと評価されます。

>>> "Hello2World".isalnum()
True
>>> "HelloWorld".isalnum()
True
>>> "2016".isalnum()
True
>>> "Hello World".isalnum()  # contains whitespace
False

str.isspace

文字列に空白文字のみが含まれている場合、 True評価されTrue 。

>>> "\t\r\n".isspace()
True
>>> " ".isspace()
True

時には文字列が "空"に見えることもありますが、文字列が空白か文字がまったく含まれていないかどうかはわかりません

>>> "".isspace()
False

このケースをカバーするには、追加テストが必要です

>>> my_str = ''
>>> my_str.isspace()
False
>>> my_str.isspace() or not my_str
True

しかし、文字列が空であるか空白文字しか含まれていないかをテストする最短の方法は、 stripを使用することです（引数なしで先頭と末尾の空白文字をすべて削除します）

>>> not my_str.strip()
True

str.translate：文字列内の文字の翻訳

Pythonはstr型のtranslateメソッドをサポートしていstrこれは、変換テーブル（置き換えに使用される）と、プロセスで削除されるべき文字を指定することを可能にします。

str.translate(table[, deletechars])

maketrans方法（ str.maketransはPython 3でとstring.maketransのPython 2で）を使用すると、変換テーブルを生成することができます。

>>> translation_table = str.maketrans("aeiou", "12345")
>>> my_string = "This is a string!"
>>> translated = my_string.translate(translation_table)
'Th3s 3s 1 str3ng!'

translateメソッドは、元の文字列の翻訳されたコピーである文字列を返します。

文字を削除する必要がある場合のみ、 table引数をNone設定できます。

>>> 'this syntax is very useful'.translate(None, 'aeiou')
'ths syntx s vry sfl'

文字列から不要な先頭/末尾文字を取り除く

str.strip 、 str.rstrip 、およびstr.lstrip 、文字列の先頭と末尾の文字を取り除く3つのメソッドが用意されています。 3つのメソッドはすべて同じシグネチャを持ち、3つすべてが不要な文字が削除された新しい文字列オブジェクトを返します。

str.strip([chars])

str.stripは、指定された文字列に作用し、引数chars含まれる先頭または末尾の文字を削除（削除）します。 charsが指定されていない場合、またはNone場合、すべての空白文字がデフォルトで削除されます。例えば：

>>> "    a line with leading and trailing space     ".strip() 
'a line with leading and trailing space'

charsが指定された場合、その文字列に含まれるすべての文字が文字列から削除され、返されます。例えば：

>>> ">>> a Python prompt".strip('> ')  # strips '>' character and space character 
'a Python prompt'

str.rstrip([chars])およびstr.lstrip([chars])

これらのメソッドはstr.strip()と同様のセマンティクスと引数をstr.strip()ますが、その違いは開始時の方向にあります。 str.rstrip()は文字列の最後から開始し、 str.lstrip()は文字列の先頭から分割します。

たとえば、 str.rstripを使用しstr.rstrip 。

>>> "     spacious string      ".rstrip()
'     spacious string'

一方、 str.lstripを使用して：

>>> "     spacious string      ".rstrip()
'spacious string      '

大文字と小文字を区別しない文字列比較

大文字と小文字を区別しない方法で文字列を比較するのは簡単なことですが、そうではありません。このセクションでは、Unicode文字列のみを考慮します（Python 3のデフォルト）。 Python 2はPython 3に比べて微妙な弱点があるかもしれないことに注意してください。後者のUnicode処理ははるかに完全です。

最初に、ユニコードで大文字と小文字を区別する変換が簡単ではないことに注意してください。 "ß"ようなtext.lower() != text.upper().lower()テキストがあります：

>>> "ß".lower()
'ß'

>>> "ß".upper().lower()
'ss'

しかし、あなたは"BUSSE"と"Buße" "BUSSE"比較したいとしましょう。 "BUSSE" 、あなたはおそらく"BUSSE"と"BUẞE"同等に比較したいと思うかもしれません。それはより新しい資本形式です。 casefoldを使用することをお勧めします。

>>> help(str.casefold)
"""
Help on method_descriptor:

casefold(...)
      S.casefold() -> str
    
     Return a version of S suitable for caseless comparisons.
"""

lower使用しないでください。 casefoldを使用できない場合は、 .upper().lower()すると役立ちます（ただし、多少の場合のみ）。

次に、アクセントを考慮する必要があります。あなたのフォントレンダラーが良いなら、おそらく"ê" == "ê"と思うかもしれませんが、そうではありません：

>>> "ê" == "ê"
False

これは、実際には

>>> import unicodedata

>>> [unicodedata.name(char) for char in "ê"]
['LATIN SMALL LETTER E WITH CIRCUMFLEX']

>>> [unicodedata.name(char) for char in "ê"]
['LATIN SMALL LETTER E', 'COMBINING CIRCUMFLEX ACCENT']

これを処理する最も簡単な方法はunicodedata.normalizeです。 NFKDの正規化を使用したいと思うかもしれませんが、ドキュメントをチェックしてください。それから、

>>> unicodedata.normalize("NFKD", "ê") == unicodedata.normalize("NFKD", "ê")
True

これを仕上げるために、ここでは関数で表現します：

import unicodedata

def normalize_caseless(text):
    return unicodedata.normalize("NFKD", text.casefold())

def caseless_equal(left, right):
    return normalize_caseless(left) == normalize_caseless(right)

文字列のリストを1つの文字列に結合する

文字列をセパレータとして使用して、 join()メソッドを使用して文字列のリストを1つの文字列にまとめることができます。たとえば、リスト内の各要素がスペースで区切られた文字列を作成できます。

>>> " ".join(["once","upon","a","time"])
"once upon a time"

次の例では、文字列要素を3つのハイフンで区切ります。

>>> "---".join(["once", "upon", "a", "time"])
"once---upon---a---time"

文字列モジュールの有用な定数

Pythonのstringモジュールは、文字列に関連する操作のための定数を提供します。それらを使用するには、 stringモジュールをインポートします。

>>> import string

string.ascii_letters ：

ascii_lowercaseとascii_uppercase連結：

>>> string.ascii_letters
'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'

string.ascii_lowercase ：

すべての小文字のASCII文字が含まれます。

>>> string.ascii_lowercase
'abcdefghijklmnopqrstuvwxyz'

string.ascii_uppercase ：

すべての大文字のASCII文字が含まれます。

>>> string.ascii_uppercase
'ABCDEFGHIJKLMNOPQRSTUVWXYZ'

string.digits ：

すべての10進数の文字が含まれます。

>>> string.digits
'0123456789'

string.hexdigits ：

すべての16進数字を含みます：

>>> string.hexdigits
'0123456789abcdefABCDEF'

string.octaldigits ：

すべての8進数の文字が含まれます。

>>> string.octaldigits
'01234567'

string.punctuation ：

Cロケールで句読点とみなされるすべての文字が含まれます。

>>> string.punctuation
'!"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~'

string.whitespace ：

空白とみなされるすべてのASCII文字を含みます：

>>> string.whitespace
' \t\n\r\x0b\x0c'

スクリプトモードでは、 print(string.whitespace)は実際の文字を出力し、 strを使用して上に返された文字列を取得します。

string.printable ：

印刷可能とみなされるすべての文字を含みます。 string.digits 、 string.ascii_letters 、 string.punctuation 、およびstring.whitespace 。

>>> string.printable
'0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ!"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~ \t\n\r\x0b\x0c'

文字列を反転する

文字列を取り、逆の順序でイテレータを返す組み込みのreversed()関数を使用して、文字列を逆にすることができます。

>>> reversed('hello')
<reversed object at 0x0000000000000000>
>>> [char for char in reversed('hello')]
['o', 'l', 'l', 'e', 'h']

reversed()の呼び出しでラップすることができます''.join()文字列を作るためにイテレータからを。

>>> ''.join(reversed('hello'))
'olleh'

初期化されていないPythonユーザーはreversed()を使用する方が読みやすくなりますが、 -1ステップで拡張スライスを使用する方が高速で簡潔になります。ここでは、関数として実装しようとします：

>>> def reversed_string(main_string):
...     return main_string[::-1]
...
>>> reversed_string('hello')
'olleh'

文字列の並び替え

Pythonは文字列を正当化するための関数を提供し、さまざまな文字列をより簡単に整列させるためのテキストパディングを可能にします。

以下はstr.ljustとstr.rjust例です：

interstates_lengths = {
    5: (1381, 2222),
    19: (63, 102),
    40: (2555, 4112),
    93: (189,305),
}
for road, length in interstates_lengths.items():
    miles,kms = length
    print('{} -> {} mi. ({} km.)'.format(str(road).rjust(4), str(miles).ljust(4), str(kms).ljust(4)))

  40 -> 2555 mi. (4112 km.)
  19 -> 63   mi. (102  km.)
   5 -> 1381 mi. (2222 km.)
  93 -> 189  mi. (305  km.)

ljustとrjustは非常に似ています。どちらもwidthパラメータとオプションのfillcharパラメータをfillcharます。これらの関数で作成された文字列は、少なくとも関数に渡されたwidthパラメータと同じ長さです。文字列のwidth alreadよりも長い場合、文字列は切り捨てられません。 fillchar引数は、デフォルトで空白文字' 'なりますが、マルチキャラクタ文字列ではなく、単一文字でなければなりません。

ljust関数は、 fillchar呼び出された文字列の終わりをwidth文字になるまでfillcharます。 rjust関数は、同様の方法で文字列の先頭をrjustます。したがって、これらの関数の名前のlとr は、 fillcharではなく元の文字列が出力文字列に配置されている側を指します。

strまたはbytesデータとunicode文字の間の変換

ファイルおよびネットワークメッセージの内容は、符号化された文字を表すことがあります。適切な表示のために、しばしばユニコードに変換する必要があります。

Python 2では、strデータをUnicode文字に変換する必要があります。デフォルト（ '' 、 ""など）はASCII文字列で、ASCII範囲外の値はエスケープ値として表示されます。 Unicode文字列はu'' （またはu""など）です。

# You get "© abc" encoded in UTF-8 from a file, network, or other data source

s = '\xc2\xa9 abc'  # s is a byte array, not a string of characters
                    # Doesn't know the original was UTF-8
                    # Default form of string literals in Python 2
s[0]                # '\xc2' - meaningless byte (without context such as an encoding)
type(s)             # str - even though it's not a useful one w/o having a known encoding

u = s.decode('utf-8')  # u'\xa9 abc'
                       # Now we have a Unicode string, which can be read as UTF-8 and printed properly
                       # In Python 2, Unicode string literals need a leading u
                       # str.decode converts a string which may contain escaped bytes to a Unicode string
u[0]                # u'\xa9' - Unicode Character 'COPYRIGHT SIGN' (U+00A9) '©'
type(u)             # unicode

u.encode('utf-8')   # '\xc2\xa9 abc'
                    # unicode.encode produces a string with escaped bytes for non-ASCII characters

Python 3では、バイトの配列（バイトリテラルと呼ばれる）をUnicode文字列に変換する必要があります。デフォルトでは現在、Unicode文字列で、バイト文字列リテラルは、今のように入力する必要がありますb'' 、 b""返されますなどのバイトリテラルのTrueのisinstance(some_val, byte)と仮定すると、 some_valエンコードされるかもしれない文字列であることをバイト数。

# You get from file or network "© abc" encoded in UTF-8

s = b'\xc2\xa9 abc' # s is a byte array, not characters
                    # In Python 3, the default string literal is Unicode; byte array literals need a leading b
s[0]                # b'\xc2' - meaningless byte (without context such as an encoding)
type(s)             # bytes - now that byte arrays are explicit, Python can show that.

u = s.decode('utf-8')  # '© abc' on a Unicode terminal
                       # bytes.decode converts a byte array to a string (which will, in Python 3, be Unicode)
u[0]                # '\u00a9' - Unicode Character 'COPYRIGHT SIGN' (U+00A9) '©'
type(u)             # str
                    # The default string literal in Python 3 is UTF-8 Unicode

u.encode('utf-8')   # b'\xc2\xa9 abc'
                    # str.encode produces a byte array, showing ASCII-range bytes as unescaped characters.

文字列が含まれています

Pythonでは、文字列に指定された部分文字列が含まれているかどうかをチェックするのが非常に直感的です。ただ、使用inオペレータ：

>>> "foo" in "foo.baz.bar"
True

注：空の文字列をテストすると常にTrue 。

>>> "" in "test"
True