Python3 – 正規表現 – 選択演算子’|’とfindall/finditerの注意点

2016-10-06 / tau / コメントする

findall()、finditer()のパターン文字列で選択演算子'|'を用いるとき、選択文字列の順序によって結果が変わってくる点に注意が必要。

たとえばreモジュール関数の場合、以下の例のようになる。

import re

s = "a,aa,aaa,aaaa,aaaaa"

print(re.findall(r'aa|aaa', s))
# ['aa', 'aa', 'aa', 'aa', 'aa', 'aa']

print(re.findall(r'aaa|aa', s))
# ['aa', 'aaa', 'aaa', 'aaa', 'aa']

[print(x.group(0), end=' ') for x in re.finditer('aa|aaa', s)]; print()
# aa aa aa aa aa aa

[print(x.group(0), end=' ') for x in re.finditer('aaa|aa', s)]; print()
# aa aaa aaa aaa aa

import re

s = "a,aa,aaa,aaaa,aaaaa"

print(re.findall(r'aa|aaa', s))

# ['aa', 'aa', 'aa', 'aa', 'aa', 'aa']

print(re.findall(r'aaa|aa', s))

# ['aa', 'aaa', 'aaa', 'aaa', 'aa']

[print(x.group(0), end=' ') for x in re.finditer('aa|aaa', s)]; print()

# aa aa aa aa aa aa

[print(x.group(0), end=' ') for x in re.finditer('aaa|aa', s)]; print()

# aa aaa aaa aaa aa

'aa|aaa'とした場合以下の順番でマッチしていく。

"a,|aa|,|aa|a,aaaa,aaaaa"
"a,|aa|,|aa|a,|aa|aa,aaaaa"
"a,|aa|,|aa|a,|aa|aa|,aaaaa"
"a,|aa|,|aa|a,|aa|aa|,|aa|aaa"
"a,|aa|,|aa|a,|aa|aa|,|aa|aa|a"

'aaa|aa'とした場合は以下の順番でマッチしていく

"a,|aa|,aaa,aaaa,aaaaa"
"a,|aa|,|aaa|,aaaa,aaaaa"
"a,|aa|,|aaa|,|aaa|a,aaaaa"
"a,|aa|,|aaa|,|aaa|a,aaaaa"
"a,|aa|,|aaa|,|aaa|a,|aaa|aa"
"a,|aa|,|aaa|,|aaa|a,|aaa|aa|"

つまり、各マッチングの段階で選択演算子'|'の左側からマッチする部分をまず探し、該当しなければ演算子の右へと判定パターンを変えていく。

このため、演算子の左のパターンが右のパターンより短いと、先にそちらがマッチングされるので右の長いパターンがマッチしなくなることがある。

この動作は、正規表現オブジェクトのメソッドについても同じ。

import re

s = "a,aa,aaa,aaaa,aaaaa"

matchobj1 = re.compile(r'aa|aaa')
matchobj2 = re.compile(r'aaa|aa')

print(matchobj1.findall(s))
# ['aa', 'aa', 'aa', 'aa', 'aa', 'aa']

print(matchobj2.findall(s))
# ['aa', 'aaa', 'aaa', 'aaa', 'aa']

[print(x.group(0), end=' ') for x in matchobj1.finditer(s)]; print()
# aa aa aa aa aa aa

[print(x.group(0), end=' ') for x in matchobj2.finditer(s)]; print()
# aa aaa aaa aaa aa

import re

s = "a,aa,aaa,aaaa,aaaaa"

matchobj1 = re.compile(r'aa|aaa')

matchobj2 = re.compile(r'aaa|aa')

print(matchobj1.findall(s))

# ['aa', 'aa', 'aa', 'aa', 'aa', 'aa']

print(matchobj2.findall(s))

# ['aa', 'aaa', 'aaa', 'aaa', 'aa']

[print(x.group(0), end=' ') for x in matchobj1.finditer(s)]; print()

# aa aa aa aa aa aa

[print(x.group(0), end=' ') for x in matchobj2.finditer(s)]; print()

# aa aaa aaa aaa aa

Python3 – 正規表現 – エスケープとraw文字列

2016-10-06 / tau / コメントする

エスケープの問題

正規表現ではいくつかの文字がパターンとしての特別の意味を持つが、その文字そのものをマッチングの対象としたいときにはバックスラッシュ(\）でエスケープする。

import re

s = "Does it work?"
print(re.search("\?", s))

# <_sre.SRE_Match object; span=(12, 13), match='?'>

import re

s = "Does it work?"

print(re.search("\?", s))

# <_sre.SRE_Match object; span=(12, 13), match='?'>

さらに検索対象の文字列にバックスラッシュが含まれている場合には、バックスラッシュ自身をエスケープしなければならない(\\)。このようなケースは、ファイルパスの区切りにバックスラッシュが使われている場合やLATexの\begin～\endなど多くある。

下の例は”\bigin”という文字列を検索する場合。

import re

s = "\\begin"
print(s)
print(re.search("\begin", s))
print(re.search("\\begin", s))
print(re.search("\\\\begin", s))

# \begin
# None
# None
# <_sre.SRE_Match object; span=(0, 6), match='\\begin'>

import re

s = "\\begin"

print(s)

print(re.search("\begin", s))

print(re.search("\\begin", s))

print(re.search("\\\\begin", s))

# \begin

# None

# <_sre.SRE_Match object; span=(0, 6), match='\\begin'>

検索される側の文字列のバックスラッシュをエスケープしなければならない(3行目)
- その文字列をprintしてみると意図した内容になっている(4行目と9行目)
次にパターン文字の方で、”\begin”とそのまま試してみるとヒットしない(5行目と10行目)
- これは最初の”\b”がPythonのエスケープシーケンス(バックスペース)として解釈されたため
そこでバックスラッシュをエスケープしてもヒットしない(6行目と11行目)
- Pythonでは文字としてのバックスラッシュとして解釈されるが、今度は正規表現として解釈したとき単独の特殊文字としての’\’となるため
2つのバックスラッシュそれぞれをエスケープするようにしてやっとヒットさせることができる(7行目と11行目)

raw文字列

Pythonでは、バックスラッシュを単なる文字として解釈するためのraw文字列が組み込まれていて、文字列リテラルの前に’r’か’R’を付けるだけでよい。”””で囲まれた複数行文字列でも同じ。

print("Hello\nPython")
# Hello
# Python

print(r"Hello\nPython")
# Hello\nPython

print("""abcd\nefgh
ijkl\nmnop""")
# abcd
# efgh
# ijkl
# mnop

print(r"""abcd\nefgh
ijkl\nmnop""")
# abcd\nefgh
# ijkl\nmnop

print("Hello\nPython")

# Hello

# Python

print(r"Hello\nPython")

# Hello\nPython

print("""abcd\nefgh

ijkl\nmnop""")

# abcd

# efgh

# ijkl

# mnop

print(r"""abcd\nefgh

ijkl\nmnop""")

# abcd\nefgh

# ijkl\nmnop

また、Python3で文字列変数の文字列をraw文字列に変換するには、repr()関数を使う。ただしその結果はシングルクォートで囲まれているため、それを取り除かなくてはいけない。

s = "Hello\nPython"
print(s)
# Hello
# Python

print(repr(s))
# 'Hello\nPython'

print(repr(s)[1:-2])
# Hello\nPytho

s = "Hello\nPython"

print(s)

# Hello

# Python

print(repr(s))

# 'Hello\nPython'

print(repr(s)[1:-2])

# Hello\nPytho

また複数行文字列の場合は、リテラルでのr指定と変数へのrepr()適用で結果が異なってくる。

s = """abc\ndef
ghi\njkl"""

print(s)
# abc
# def
# ghi
# jkl

print(repr(s))
# 'abc\ndef\nghi\njkl'

s = r"""ABC\nDEF

GHI\nJKL"""
print(s)
# ABC\nDEF
# GHI\nJKL

print(repr(s))
# 'ABC\\nDEF\nGHI\\nJKL'

s = """abc\ndef

ghi\njkl"""

print(s)

# abc

# def

# ghi

# jkl

print(repr(s))

# 'abc\ndef\nghi\njkl'

s = r"""ABC\nDEF

GHI\nJKL"""

print(s)

# ABC\nDEF

# GHI\nJKL

print(repr(s))

# 'ABC\\nDEF\nGHI\\nJKL'

Python3 – 正規表現 – MatchObject

2016-10-06 / tau / コメントする

概要

search()などのreモジュール関数や正規表現オブジェクトメソッドが実行の結果マッチした場合に、MatchObjectオブジェクトが返される。以下、MatchObjectのオブジェクトをmatchオブジェクトと表現する。matchオブジェクトは常にブール値Trueを持ち、matchオブジェクトそのものを判定式に使ってマッチしたかどうかの判定ができる。

match = re.search(pattern, string)
if match:
    # マッチした場合の処理
else:
    # マッチしなかった場合の処理

match = re.search(pattern, string)

if match:

# マッチした場合の処理

else:

# マッチしなかった場合の処理

matchオブジェクトの文字列表現には、(最初に)ヒットした場所の範囲と、マッチした内容が含まれている。

import re

s = "The rain in Spain stays mainly in the plain."

print(re.search(r"in", s))
# <_sre.SRE_Match object; span=(6, 8), match='in'>

import re

s = "The rain in Spain stays mainly in the plain."

print(re.search(r"in", s))

# <_sre.SRE_Match object; span=(6, 8), match='in'>

正規表現・文字列情報

re

match.re

matchを生成した正規表現オブジェクト。

string

match.string

matchを生成したsearch()、match()へ渡された文字列。

import re

match = re.search(r'\b\w{4}\b', "The rain in Spain")
print(match.string)
# The rain in Spain
print(match.re)
# re.compile('\\b\\w{4}\\b')

import re

match = re.search(r'\b\w{4}\b', "The rain in Spain")

print(match.string)

# The rain in Spain

print(match.re)

# re.compile('\\b\\w{4}\\b')

グループ指定しない場合のマッチング結果

group()、start()、end()、span()

match.group()、match.start()、match.end()、match.span()

group（）はマッチした部分文字列、start()とend()はマッチした部分文字列の開始位置と終了位置、span()は(開始位置, 終了位置)のタプル。

import re
match = re.search(r'in', "The rain in Spain")
print(match.group()) # in
print(match.start()) # 6
print(match.end())   # 8
print(match.span())  # (6, 8)

import re

match = re.search(r'in', "The rain in Spain")

print(match.group()) # in

print(match.start()) # 6

print(match.end()) # 8

print(match.span()) # (6, 8)

グループ指定した場合のマッチング結果

group()

match.group()、match.group([group1, ...])

引数がない場合は、マッチしたもの全てが返される。引数がある場合はグループを指定(数字のほかグループ名でも可)。

groups()

match.groups()

マッチしたグループを要素とするタプルとする。

lastindex

match.lastindex

複数グループの最終インデックス。

import re

match = re.search(r'(\w+) (\w+)', "The rain in Spain")
print(match.group())   # The rain
print(match.groups())  # ('The', 'rain')
print(match.lastindex) # 2
print(match.group(0))  # The rain
print(match.group(1))  # The
print(match.group(2))  # rain

import re

match = re.search(r'(\w+) (\w+)', "The rain in Spain")

print(match.group()) # The rain

print(match.groups()) # ('The', 'rain')

print(match.lastindex) # 2

print(match.group(0)) # The rain

print(match.group(1)) # The

print(match.group(2)) # rain

Python3 – 正規表現 – モジュール定数

2016-10-06 / tau / コメントする

ここでは正規表現の操作に使われるモジュール定数を整理する。

re.A/re. ASCII

\b、\B、\d、\D、\s、\S、\w、\Wにおいて、ASCII文字のみでマッチングを行う。Unicodeパターンでのみ意味があり、バイト列パターンでは無視される。

import re

ptn = r'\b\w+\b'
regex_obj = re.compile(ptn)
regex_obj_ascii = re.compile(ptn, flags=re.ASCII)

s = "プログラミング言語Python"
print(regex_obj.findall(s))
# ['プログラミング言語Python']
print(regex_obj_ascii.findall(s))
# ['Python']

s = "プログラミング言語　Python"
print(regex_obj.findall(s))
# ['プログラミング言語', 'Python']
print(regex_obj_ascii.findall(s))
# ['Python']

import re

ptn = r'\b\w+\b'

regex_obj = re.compile(ptn)

regex_obj_ascii = re.compile(ptn, flags=re.ASCII)

s = "プログラミング言語Python"

print(regex_obj.findall(s))

# ['プログラミング言語Python']

print(regex_obj_ascii.findall(s))

# ['Python']

s = "プログラミング言語　Python"

print(regex_obj.findall(s))

# ['プログラミング言語', 'Python']

print(regex_obj_ascii.findall(s))

# ['Python']

re.I/re.IGNORECASE

英大文字・小文字を区別せずにマッチングを行う。{A-Z]のような表現で小文字ともマッチする。現在のロケールに影響を受けず、Unicode文字に対しても動作する。

import re

s = "abc DEF"
print(re.findall(r'\b[A-Z]+\b', s))
# ['DEF']
print(re.findall(r'\b[A-Z]+\b', s, flags=re.IGNORECASE))
# ['abc', 'DEF']

s = "abc DEF ｇｅｈ ＩＪＫ"
print(re.findall(r'\b[A-ZＡ-Ｚ]+\b', s))
# ['DEF', 'ＩＪＫ']
print(re.findall(r'\b[A-ZＡ-Ｚ]+\b', s, flags=re.IGNORECASE))
# ['abc', 'DEF', 'ｇｅｈ', 'ＩＪＫ']

import re

s = "abc DEF"

print(re.findall(r'\b[A-Z]+\b', s))

# ['DEF']

print(re.findall(r'\b[A-Z]+\b', s, flags=re.IGNORECASE))

# ['abc', 'DEF']

s = "abc DEF ｇｅｈＩＪＫ"

print(re.findall(r'\b[A-ZＡ-Ｚ]+\b', s))

# ['DEF', 'ＩＪＫ']

print(re.findall(r'\b[A-ZＡ-Ｚ]+\b', s, flags=re.IGNORECASE))

# ['abc', 'DEF', 'ｇｅｈ', 'ＩＪＫ']

re.L/re.LOCALE

\b、\B、\s、\S、\w、\Wにおいて、現在のロケールに従ったマッチングを行う。バイト列でのみ意味を持つ。非推奨。

re.M/re.MULTILINE

デフォルトでは'^'は文字列全体の先頭に、'$'は文字列全体の末尾にのみマッチするが、このフラグにより、'^'は文字列の先頭と各行の先頭(各改行の直後)、'$'は文字列の末尾と各行の末尾(各改行のの直前)とマッチする。

import re

s = """Love the life you live.
Live the life you love."""

print(re.findall(r'^L\w*', s))
# ['Love']
print(re.findall(r'\w*e.$', s))
# ['love.']

print(re.findall(r'^L\w*', s, flags=re.MULTILINE))
# ['Love', 'Live']
print(re.findall(r'\w*e.$', s, flags=re.MULTILINE))
# ['live.', 'love.']

import re

s = """Love the life you live.

Live the life you love."""

print(re.findall(r'^L\w*', s))

# ['Love']

print(re.findall(r'\w*e.$', s))

# ['love.']

print(re.findall(r'^L\w*', s, flags=re.MULTILINE))

# ['Love', 'Live']

print(re.findall(r'\w*e.$', s, flags=re.MULTILINE))

# ['live.', 'love.']

re.S/re.DOTALL

デフォルトでは'.'は改行にマッチしないが、このフラグにより'.'を改行を含む任意の文字とマッチさせる。

import re

s = """Love the life you live.
Live the life you love."""

print(re.findall(r'.+', s))
['Love the life you live.', 'Live the life you love.']

print(re.findall(r'.+', s, flags=re.DOTALL))
['Love the life you live.\nLive the life you love.']

import re

s = """Love the life you live.

Live the life you love."""

print(re.findall(r'.+', s))

['Love the life you live.', 'Live the life you love.']

print(re.findall(r'.+', s, flags=re.DOTALL))

['Love the life you live.\nLive the life you love.']

re.X/re.VERBOSE

このフラグにより、パターン文字列内に改行・インデントを入れたりコメントを入れるなど、より読みやすい正規表現を書くことができる。コメントには'#'を使う。

Python3 – 正規表現 – 正規表現オブジェクトメソッド

2016-10-06 / tau / コメントする

概要

reモジュールではre.RegexObjectクラスが定義されている。パターン文字列をコンパイルするとRegexObjectのオブジェクトが生成され、そのパターンはそのプロパティとして保持される。このクラスの各メソッドで、パターンを任意のテキストに適用する。

reモジュール関数を使う場合は実行のたびにパターン文字列とフラグを指定し、その都度コンパイルされる。一方、正規表現オブジェクトのメソッドを使う場合は、一度パターンをコンパイルしておけば、その後の操作でコンパイルのオーバーヘッドが生じない。フラグはコンパイル時に指定する。

import re

regex = re.compile(r'life')

print(regex.search("Love the life you live."))
# <_sre.SRE_Match object; span=(9, 13), match='life'>

print(regex.search("Live the life you love."))
# <_sre.SRE_Match object; span=(9, 13), match='life'>

import re

regex = re.compile(r'life')

print(regex.search("Love the life you live."))

# <_sre.SRE_Match object; span=(9, 13), match='life'>

print(regex.search("Live the life you love."))

# <_sre.SRE_Match object; span=(9, 13), match='life'>

パターンの検索

search()

regex.search(string,[ pos[, endpos]])

re.search()関数と同じ機能で、stringの任意の位置で、最初にregexにマッチした時にMatchObjectのオブジェクトを返す。マッチしなければNoneを返す。

posは検索開始位置で先頭が0。デフォルト値は0で先頭から検索する。

endposは検索範囲の終了位置で、endpos-1文字目までが検索範囲となる。デフォルトでは文字列の最後まで検索する。

import re

regex1 = re.compile(r'ab')
regex2 = re.compile(r'cd')
regex3 = re.compile(r'ef')
s = r"abcdabcd"

print(re.search(regex1, s))
# <_sre.SRE_Match object; span=(0, 2), match='ab'>
print(re.search(regex2, s))
# <_sre.SRE_Match object; span=(2, 4), match='cd'>
print(re.search(regex3, s))
# None

print(regex1.search(s, 2))
# <_sre.SRE_Match object; span=(4, 6), match='ab'>
print(regex1.search(s, 2, 5))
# None

import re

regex1 = re.compile(r'ab')

regex2 = re.compile(r'cd')

regex3 = re.compile(r'ef')

s = r"abcdabcd"

print(re.search(regex1, s))

# <_sre.SRE_Match object; span=(0, 2), match='ab'>

print(re.search(regex2, s))

# <_sre.SRE_Match object; span=(2, 4), match='cd'>

print(re.search(regex3, s))

# None

print(regex1.search(s, 2))

# <_sre.SRE_Match object; span=(4, 6), match='ab'>

print(regex1.search(s, 2, 5))

# None

match()

regex.match(string[, pos[, endpos]])

re.match()関数と同じ機能で、regexがstringの先頭でマッチするときだけMatchObjectオブジェクトを返す。pos、endposはregex.search()と同じ意味。

import re

regex1 = re.compile(r'ab')
regex2 = re.compile(r'cd')
s = r"abcdabcd"

print(re.match(regex1, s))
# <_sre.SRE_Match object; span=(0, 2), match='ab'>
print(re.match(regex2, s))
# None

import re

regex1 = re.compile(r'ab')

regex2 = re.compile(r'cd')

s = r"abcdabcd"

print(re.match(regex1, s))

# <_sre.SRE_Match object; span=(0, 2), match='ab'>

print(re.match(regex2, s))

# None

fullmatch()

regex.fullmatch(string[, pos[, endpos]])

re.fullmatch()関数と同じ機能で、regexがstring全体にマッチするときだけMatchObjectオブジェクトを返す。pos、endposはregex.search()と同じ意味。

import re

s = r"abcdabcd"

regex = re.compile(r'abcdabcd')
print(re.fullmatch(regex, s))
# <_sre.SRE_Match object; span=(0, 8), match='abcdabcd'>

regex = re.compile(r'abcd')
print(re.fullmatch(regex, s))
# None

regex = re.compile(r'.*')
print(re.fullmatch(regex, s))
# <_sre.SRE_Match object; span=(0, 8), match='abcdabcd'>

regex = re.compile(r'.{5}')
print(re.fullmatch(regex, s))
# None

import re

s = r"abcdabcd"

regex = re.compile(r'abcdabcd')

print(re.fullmatch(regex, s))

# <_sre.SRE_Match object; span=(0, 8), match='abcdabcd'>

regex = re.compile(r'abcd')

print(re.fullmatch(regex, s))

# None

regex = re.compile(r'.*')

print(re.fullmatch(regex, s))

# <_sre.SRE_Match object; span=(0, 8), match='abcdabcd'>

regex = re.compile(r'.{5}')

print(re.fullmatch(regex, s))

# None

findall()

regex.findall(string[, pos[, endpos]])

re.findall()関数と同じ機能でregexにマッチする部分列のリストを返す。pos、endposはregex.search()と同じ意味。

import re

s = r"abcdabcd"

regex = re.compile(r'ab')
print(regex.findall(s))
# ['ab', 'ab']

regex = re.compile(r'ef')
print(regex.findall(s))
# []

regex = re.compile(r'.{3}')
print(regex.findall(s))
# ['abc', 'dab']

import re

s = r"abcdabcd"

regex = re.compile(r'ab')

print(regex.findall(s))

# ['ab', 'ab']

regex = re.compile(r'ef')

print(regex.findall(s))

# []

regex = re.compile(r'.{3}')

print(regex.findall(s))

# ['abc', 'dab']

finditer()

regex.finditer(string[, pos[, endpos]])

re.finditer()関数と同じ機能で、regexにマッチする部分列のイテレータを返す。pos、endposはsearch()と同じ意味。

import re

s = r"abcdabcd"

regex = re.compile(r'ab')
[print(x) for x in regex.finditer(s)]
# <_sre.SRE_Match object; span=(0, 2), match='ab'>
# <_sre.SRE_Match object; span=(4, 6), match='ab'>

regex = re.compile(r'ef')
[print(x) for x in regex.finditer(s)]
# 空のイテレータ

regex = re.compile(r'.{3}')
[print(x) for x in regex.finditer(s)]
# <_sre.SRE_Match object; span=(0, 3), match='abc'>
# <_sre.SRE_Match object; span=(3, 6), match='dab'>

regex = re.compile(r'ab')
[print(x) for x in regex.finditer(s, 2, 6)]
# <_sre.SRE_Match object; span=(4, 6), match='ab'>

import re

s = r"abcdabcd"

regex = re.compile(r'ab')

[print(x) for x in regex.finditer(s)]

# <_sre.SRE_Match object; span=(0, 2), match='ab'>

# <_sre.SRE_Match object; span=(4, 6), match='ab'>

regex = re.compile(r'ef')

[print(x) for x in regex.finditer(s)]

# 空のイテレータ

regex = re.compile(r'.{3}')

[print(x) for x in regex.finditer(s)]

# <_sre.SRE_Match object; span=(0, 3), match='abc'>

# <_sre.SRE_Match object; span=(3, 6), match='dab'>

regex = re.compile(r'ab')

[print(x) for x in regex.finditer(s, 2, 6)]

# <_sre.SRE_Match object; span=(4, 6), match='ab'>

分割

split()

regex.split(string, maxsplit=0)

re.split()関数と同じ機能で、regexにマッチする部分列でstringを切り分ける。pos、endposはsearch()と同じ意味。

置換

sub()

regex.sub(repl, string, count=0)

re.sub()関数と同じ機能でstring中のregexにマッチする部分をreplで置き換える。replには文字列を返す関数も指定可能。pos、endposはsearch()と同じ意味。

subn()

regex.subn(repl, string, count=0)

re.subn()関数と同じ機能で、置換後にタプルで(置換後の文字列, 置換数)を返す。pos、endposはsearch()と同じ意味。

Python3 – 正規表現 – モジュール関数

2016-10-06 / tau / コメントする

概要

reモジュールの関数は、パターンと文字列を直接指定してマッチングなどの操作を行う。

引数の中のflagsについては、reモジュールで定義された定数を指定する。複数のflagsを指定する場合は、ビットごとのOR('|'演算子)を使って組み合わせる。

パターンは実行に先立ってコンパイルされるので、同じパターンを複数回用いる場合には、re.compile()関数でパターンをコンパイルし、コンパイルされたRegexObjectオブジェクトのメソッドを用いる方がよい。

正規表現のコンパイル

compile()

re.compile(pattern, flags=0)

正規表現パターンを正規表現オブジェクトにコンパイルする。正規表現オブジェクトのメソッド群で、以下のモジュール関数と同等の操作を行うことができる。

以下のモジュール関数を使う場合はflagsを関数ごとに指定するが、正規表現オブジェクトを使う場合は、compile()関数の引数でflagsを指定する。

パターンの検索

search()

re.search(pattern, string, flags=0)

stringの任意の位置で、最初にpatternにマッチした時にMatchObjectのオブジェクトを返す。マッチしなければNoneを返す。

import re
s = r"abcdabcd"
print(re.search(r'ab', s))
# <_sre.SRE_Match object; span=(0, 2), match='ab'>
print(re.search(r'cd', s))
# <_sre.SRE_Match object; span=(2, 4), match='cd'>
print(re.search(r'ef', s))
# None

import re

s = r"abcdabcd"

print(re.search(r'ab', s))

# <_sre.SRE_Match object; span=(0, 2), match='ab'>

print(re.search(r'cd', s))

# <_sre.SRE_Match object; span=(2, 4), match='cd'>

print(re.search(r'ef', s))

# None

match()

re.match(pattern, string, flags=0)

stringの先頭でpatternにマッチすればMatchObjectのオブジェクトを返す。マッチしなければNoneを返す。stringの途中ではマッチしない。

import re
s = r"abcdabcd"
print(re.match(r'ab', s))
# <_sre.SRE_Match object; span=(0, 2), match='ab'>
print(re.match(r'cd', s))
# None

import re

s = r"abcdabcd"

print(re.match(r'ab', s))

# <_sre.SRE_Match object; span=(0, 2), match='ab'>

print(re.match(r'cd', s))

# None

fullmatch()

re.fullmatch(pattern, string, flags=0)

patternがstring全体にマッチしたときだけMatcObjectのオブジェクトを返し、それ以外はNoneを返す。

import re
s = r"abcdabcd"
print(re.fullmatch(r'abcdabcd', s))
# <_sre.SRE_Match object; span=(0, 8), match='abcdabcd'>
print(re.fullmatch(r'abcd', s))
# None
print(re.fullmatch(r'.*', s))
# <_sre.SRE_Match object; span=(0, 8), match='abcdabcd'>
print(re.fullmatch(r'.{5}', s))
# None

import re

s = r"abcdabcd"

print(re.fullmatch(r'abcdabcd', s))

# <_sre.SRE_Match object; span=(0, 8), match='abcdabcd'>

print(re.fullmatch(r'abcd', s))

# None

print(re.fullmatch(r'.*', s))

# <_sre.SRE_Match object; span=(0, 8), match='abcdabcd'>

print(re.fullmatch(r'.{5}', s))

# None

findall()

re.findall(pattern, string, flags=0)

string中でpatternにマッチする全ての部分文字列を要素とするリストを返す。マッチする部分がなければ空のリスト([])を返す。先頭からマッチした部分を取り除きながらサーチしていく。

import re
s = r"abcdabcd"
print(re.findall(r'ab', s))
# ['ab', 'ab']
print(re.findall(r'ef', s))
# []
print(re.findall(r'.{3}', s))
# ['abc', 'dab']

import re

s = r"abcdabcd"

print(re.findall(r'ab', s))

# ['ab', 'ab']

print(re.findall(r'ef', s))

# []

print(re.findall(r'.{3}', s))

# ['abc', 'dab']

finditer()

re.finditer(pattern, string, flags=0)

string中でpatternにマッチした結果のMatchObjectオブジェクトのイテレータを返す。マッチする部分がなければ空のイテレータを返す。先頭からマッチした部分を取り除きながらサーチしていく。

import re
s = r"abcdabcd"
[print(x) for x in re.finditer(r'ab', s)]
# <_sre.SRE_Match object; span=(0, 2), match='ab'>
# <_sre.SRE_Match object; span=(4, 6), match='ab'>
[print(x) for x in re.finditer(r'ef', s)]
# 空のイテレータ
[print(x) for x in re.finditer(r'.{3}', s)]
# <_sre.SRE_Match object; span=(0, 3), match='abc'>
# <_sre.SRE_Match object; span=(3, 6), match='dab'>

import re

s = r"abcdabcd"

[print(x) for x in re.finditer(r'ab', s)]

# <_sre.SRE_Match object; span=(0, 2), match='ab'>

# <_sre.SRE_Match object; span=(4, 6), match='ab'>

[print(x) for x in re.finditer(r'ef', s)]

# 空のイテレータ

[print(x) for x in re.finditer(r'.{3}', s)]

# <_sre.SRE_Match object; span=(0, 3), match='abc'>

# <_sre.SRE_Match object; span=(3, 6), match='dab'>

分割

split()

re.split(pattern, string, maxsplit=0, flags=0)

stringをすべてのpatternにマッチする部分で分割し、それらを要素とするリストを返す。patternにマッチする部分は除かれる。マッチする部分がなければ、stringを1つの要素とするリストが返される。

maxsplitに1以上の数nを指定すると、先頭から最大n個の分割が発生し、残りはリストの最後の要素となる。

import re
s =r"she sells sea shells by the seashore"
print(re.split(r' ', s))
# ['she', 'sells', 'sea', 'shells', 'by', 'the', 'seashore']
print(re.split(r'se', s))
# ['she ', 'lls ', 'a shells by the ', 'ashore']
print(re.split(r'xyz', s))
# ['she sells sea shells by the seashore']
print(re.split(r' ', s, maxsplit=3))
# ['she', 'sells', 'sea', 'shells by the seashore']
print(re.split(r' ', s, maxsplit=10))
# ['she', 'sells', 'sea', 'shells', 'by', 'the', 'seashore']

import re

s =r"she sells sea shells by the seashore"

print(re.split(r' ', s))

# ['she', 'sells', 'sea', 'shells', 'by', 'the', 'seashore']

print(re.split(r'se', s))

# ['she ', 'lls ', 'a shells by the ', 'ashore']

print(re.split(r'xyz', s))

# ['she sells sea shells by the seashore']

print(re.split(r' ', s, maxsplit=3))

# ['she', 'sells', 'sea', 'shells by the seashore']

print(re.split(r' ', s, maxsplit=10))

# ['she', 'sells', 'sea', 'shells', 'by', 'the', 'seashore']

patternが先頭の部分に一致する場合は、リストの最初は空文字列から始まり、最後の部分に一致する場合はリストの最終要素が空文字列になる。

import re
s = "abracadabra"
print(re.split(r'ab', s))
# ['', 'racad', 'ra']
print(re.split(r'ra', s))
# ['ab', 'cadab', '']

import re

s = "abracadabra"

print(re.split(r'ab', s))

# ['', 'racad', 'ra']

print(re.split(r'ra', s))

# ['ab', 'cadab', '']

空文字列('')では分割されない。patternとして空文字1文字を指定するとエラー。

置換

sub()

re.sub(pattern, repl, string, count=0, flags=0)

string中でpatternにマッチする部分文字列をreplの文字列で置換する。countで正の整数値を指定すると、先頭から最大その回数だけ置換を行う。

import re
s = "she sells sea shells by the seashore"
print(re.sub(r'sh', "++", s))
# ++e sells sea ++ells by the sea++ore
print(re.sub(r'sh', "++", s, count=2))
# ++e sells sea ++ells by the seashore

import re

s = "she sells sea shells by the seashore"

print(re.sub(r'sh', "++", s))

# ++e sells sea ++ells by the sea++ore

print(re.sub(r'sh', "++", s, count=2))

# ++e sells sea ++ells by the seashore

空文字列とのマッチは、前のマッチの直後以外に置換される。

import re
print(re.sub(r'x*', '-', "abcde"))
# -a-b-c-d-e-

import re

print(re.sub(r'x*', '-', "abcde"))

# -a-b-c-d-e-

replには文字列を返す関数を指定できる。

import re

def repl_func(matchobj):
    if matchobj.group(0).isalpha():
        return 'A'
    else:
        return '0'

print(re.sub(r'[A-Z0-9]', repl_func, "TK-80-BS"))
# AA-00-AA

import re

def repl_func(matchobj):

if matchobj.group(0).isalpha():

return 'A'

else:

return '0'

print(re.sub(r'[A-Z0-9]', repl_func, "TK-80-BS"))

# AA-00-AA

subn()

re.subn(pattern, repl, string, count=0, fkags=0)

sub()と同じ操作を行うが、タプルで(置換後の文字列, 置換数)を返す。

import re
s = "she sells sea shells by the seashore"
print(re.subn(r'sh', "++", s))
# ('++e sells sea ++ells by the sea++ore', 3)
print(re.subn(r'sh', "++", s, count=2))
# ('++e sells sea ++ells by the seashore', 2)

import re

s = "she sells sea shells by the seashore"

print(re.subn(r'sh', "++", s))

# ('++e sells sea ++ells by the sea++ore', 3)

print(re.subn(r'sh', "++", s, count=2))

# ('++e sells sea ++ells by the seashore', 2)

Python3 – エスケープシーケンス

2016-10-06 / tau / コメントする

Pythonのエスケープシーケンス一覧

\\	バックスラッシュ(`'\'`)
`\'`	シングルクォーテーション(`"'"`)
`\"`	ダブルクォーテーション(`'"'`)
`\a`	ベル
`\b`	バックスペース
`\f`	改ページ
`\r`	キャリッジリターン
`\n`	改行
`\t`	水平タブ
`\v`	垂直タブ
`￥N{name}`	Unicodeデータベース中で名前`name`を持つ文字
`\uxxxx`	16ビットの16進数`xxxx`を持つUnicode文字
`\Uxxxxxxxx`	32ビットの16進数`xxxxxxxx`を持つUnicode文字
`\ooo`	8進数oooを持つASCII文字
`\xhh`	16進数hhを持つASCII文字
`\0`	NULL
`\+改行`	改行の直前(文末)が\の場合は次の行が継続

Python3 – 正規表現

2016-10-06 / tau / コメントする

Pythonでの正規表現の扱い

Pythonでは、パターン・マッチングを以下のいずれかの方法で行い、その結果をMatchObjectオブジェクトとして返す。

パターンと文字列を指定して、reモジュールで定義された関数を実行する
パターン文字列を正規表現オブジェクトとしてコンパイルしておき、そのメソッドで文字列を指定して実行する

reモジュール関数を使う方法

モジュール関数で実行する例は次の通り。実行結果はMatchObjectのオブジェクトとして返されるが、その文字列表現のspanのところに4文字目～8-1文字目でヒットしたことが記録されている。

import re

s = "The rain in Spain stays mainly in the plain."

print(re.search(r"rain", s))

# <_sre.SRE_Match object; span=(4, 8), match='rain'>
# マッチオブジェクトが返される

import re

s = "The rain in Spain stays mainly in the plain."

print(re.search(r"rain", s))

# <_sre.SRE_Match object; span=(4, 8), match='rain'>

# マッチオブジェクトが返される

パターン文字列を正規表現オブジェクトにコンパイルする方法

正規表現オブジェクトにコンパイルして検索する方法は次の通り。検索結果は先と同じMatchObjectオブジェクト。

import re

s = "The rain in Spain stays mainly in the plain."

ptnobj = re.compile(r"rain")
print(ptnobj)
print(ptnobj.search(s))

# re.compile('rain')
# <_sre.SRE_Match object; span=(4, 8), match='rain'>

import re

s = "The rain in Spain stays mainly in the plain."

ptnobj = re.compile(r"rain")

print(ptnobj)

print(ptnobj.search(s))

# re.compile('rain')

# <_sre.SRE_Match object; span=(4, 8), match='rain'>

Python3 – 文字列とコレクション

2016-10-02 / tau / コメントする

リストと文字列

list()関数で文字列をリストに分解し、join()メソッドで区切り文字を''(空文字)で指定してリストを文字列に結合。

s = "Python"

l = list(s)
print(l)
# ['P', 'y', 't', 'h', 'o', 'n']

s = "".join(l)
print(s)
# Python

s = "Python"

l = list(s)

print(l)

# ['P', 'y', 't', 'h', 'o', 'n']

s = "".join(l)

print(s)

# Python

数値要素のリストを文字列要素のリストにするには、map()関数でstr()関数を適用する。

number_list = [0, 1, 2, 3]
print(list(map(str, number_list)))
# ['0', '1', '2', '3']

number_list = [0, 1, 2, 3]

print(list(map(str, number_list)))

# ['0', '1', '2', '3']

ただしmap()関数はいろいろと注意が必要。

setと文字列

set()で文字列の重複した文字を集約したセットが得られる。文字列の順番は固定されず、実行ごとにも異なる。

s = "abcabcabc"
print(set(s))
# {'b', 'a', 'c'}

s = "abcabcabc"

print(set(s))

# {'b', 'a', 'c'}

Python3 – 文字列

2016-09-30 / tau / コメントする

内容の取得

文字列長

文字列長はlen()関数で得られる。

one = "first"
two = "second"
print(len(one), len(two))
# 5 6

one = "first"

two = "second"

print(len(one), len(two))

# 5 6

一文字取得

配列のように文字列中の位置を指定して、一文字取得する。開始位置は0。-1で最後の文字を指定でき、そこから順に-2、-3と先頭に向けて遡る。

s = "ABCD"
print(s[0], s[1], s[2])
# A B C
print(s[-1], s[-2], s[-3])
# D C B

s = "ABCD"

print(s[0], s[1], s[2])

# A B C

print(s[-1], s[-2], s[-3])

# D C B

イテレータ、リストによる連続取得

文字列はイテレータ。

st = "Python"
for chr in st:
    print(chr, end=' ')
# P y t h o n

st = "Python"

for chr in st:

print(chr, end=' ')

# P y t h o n

list()関数で一文字ずつのリストが得られる。

st = "Python"
print(list(st))
# ['P', 'y', 't', 'h', 'o', 'n']

st = "Python"

print(list(st))

# ['P', 'y', 't', 'h', 'o', 'n']

文字の出現回数

count(sub[, start[, end]])は元の文字列の中の部分文字列subの出現回数を返す。start、endはオプションで指定可能。

s = "aababcabcd"

print(s.count('a'))
# 4

print(s.count("ab"))
# 3

print(s.count('b', 1))
# 3

print(s.count('b', 1, 6))
# 2

s = "aababcabcd"

print(s.count('a'))

# 4

print(s.count("ab"))

# 3

print(s.count('b', 1))

# 3

print(s.count('b', 1, 6))

# 2

部分文字列の取得(スライス)

以下の記法で部分文字列を取り出せる。ただし取り出される最後の文字列は終了位置-1番目の文字。

[開始位置:終了位置:ステップ値]

1	[開始位置:終了位置:ステップ値]

具体例は以下の通り。

st = "0123456789"

print(st[:])
# 0123456789
# 全部省略した場合は文字列全体

print(st[6:])
# 6789
# 開始位置から最後まで

print(st[:4])
# 0123
# 先頭から指定位置まで(最後の文字は[指定位置-1]文字目

print(st[3:7])
# 3456
# 3文字目から6文字目まで

print(st[-5:-1])
# 5678
# インデックスに負数も使えるが、開始位置:終了位置に注意

print(st[1:8:2])
# 1357
# 1文字目から8文字目まで2文字ステップで

print(st[3:3])
print(st[5:2])
# どちらも""(空行)
# 開始位置 < 終了位置でないといけない

st = "0123456789"

print(st[:])

# 0123456789

# 全部省略した場合は文字列全体

print(st[6:])

# 6789

# 開始位置から最後まで

print(st[:4])

# 0123

# 先頭から指定位置まで(最後の文字は[指定位置-1]文字目

print(st[3:7])

# 3456

# 3文字目から6文字目まで

print(st[-5:-1])

# 5678

# インデックスに負数も使えるが、開始位置:終了位置に注意

print(st[1:8:2])

# 1357

# 1文字目から8文字目まで2文字ステップで

print(st[3:3])

print(st[5:2])

# どちらも""(空行)

# 開始位置 < 終了位置でないといけない

正のステップ値の場合は検索方向が左→右なので以下の関係でなければならない。

[開始位置:終了位置] -> 開始位置 < 終了位置

1	[開始位置:終了位置] -> 開始位置 < 終了位置

負のステップ値を使うと、最後尾から先頭へ向かって文字を取り出す。特にステップ値を-1とすると、1文字ずつ前へ向かって取り出すので、文字列の反転に便利。ただし開始位置と終了位置に注意が必要。

st = "0123456789"

print(st[::-2])
# 97531
# 全ての文字列に対して最後尾から1文字おきに取り出す

print(st[::-1])
# 9876543210
# ステップ値を-1とすると逆向きに1文字ずつ取り出す

print(st[7:3:-1])
print(st[-3:-7:-1])
# どちらも7654
# 部分文字列の指定は、後方の開始値:前方の終了値の順で
# 位置指定には負の値も使える

print(st[3:7:-1])
# ''(空行)
# 逆順検索の場合は開始位置 > 終了位置でなければならない

print(st[9:0:-1])
print(st[9:-1:-1])
# 987654321
# ''（空行） -> -1が最後尾の文字となって検索方向に合わないため
# 先頭の文字が取り出せない

print(st[-1:-11:-1])
# 9876543210
# これでok

st = "0123456789"

print(st[::-2])

# 97531

# 全ての文字列に対して最後尾から1文字おきに取り出す

print(st[::-1])

# 9876543210

# ステップ値を-1とすると逆向きに1文字ずつ取り出す

print(st[7:3:-1])

print(st[-3:-7:-1])

# どちらも7654

# 部分文字列の指定は、後方の開始値:前方の終了値の順で

# 位置指定には負の値も使える

print(st[3:7:-1])

# ''(空行)

# 逆順検索の場合は開始位置 > 終了位置でなければならない

print(st[9:0:-1])

print(st[9:-1:-1])

# 987654321

# ''（空行） -> -1が最後尾の文字となって検索方向に合わないため

# 先頭の文字が取り出せない

print(st[-1:-11:-1])

# 9876543210

# これでok

負のステップ値の場合には検索方向が右→左になるので、以下の関係でなければならない。

[開始位置:終了位置] -> 開始位置 > 終了位置

1	[開始位置:終了位置] -> 開始位置 > 終了位置

n文字目からm文字取得したい時。

s = "123456789"
n = 1
m = 3
print(s[n-1:n-1+m])
# 123

s = "123456789"

n = 1

m = 3

print(s[n-1:n-1+m])

# 123

スライスとfinde/rfindでは開始位置・終了位置の指定の考え方が違ってくる。

特定文字での分割

split()メソッドは、指定した文字列で元の文字列を分解し、リストで返す。

s = "Bibbidi--Bobbidi--Boo"

print(s.split("--"))
# ['Bibbidi', 'Bobbidi', 'Boo']

s = "Bibbidi--Bobbidi--Boo"

print(s.split("--"))

# ['Bibbidi', 'Bobbidi', 'Boo']

partition()メソッドは指定文字の最初の出現位置で文字列を分割し、タプルで結果を返す。

s = "Bibbidi--Bobbidi--Boo"

print(s.partition("--"))
# ('Bibbidi', '--', 'Bobbidi--Boo')
# 戻り値はタプル

print(s.partition("$$"))
# ('Bibbidi--Bobbidi--Boo', '', '')
# 区切り文字が見つからない場合の戻り値

s = "Bibbidi--Bobbidi--Boo"

print(s.partition("--"))

# ('Bibbidi', '--', 'Bobbidi--Boo')

# 戻り値はタプル

print(s.partition("$$"))

# ('Bibbidi--Bobbidi--Boo', '', '')

# 区切り文字が見つからない場合の戻り値

内容の判定

stringオブジェクトの以下のメソッドは、それぞれの条件に合致した場合にTrueを返す。空文字列に対しては全てFalseを返す。

isalpha()

全ての文字がアルファベットの場合にTrue。

>>> print("aA".isalpha())
True
>>> print("a0".isalpha())
False

>>> print("aA".isalpha())

True

>>> print("a0".isalpha())

False

isdigit()

全ての文字が数字の場合にTrue。

>>> print("00".isdigit())
True
>>> print("0a".isdigit())
False

>>> print("00".isdigit())

True

>>> print("0a".isdigit())

False

isalnum()

全ての文字がアルファベットか数字の場合にTrue。

>>> print("0aA".isalnum())
True
>>> print("0a+".isalnum())
False

>>> print("0aA".isalnum())

True

>>> print("0a+".isalnum())

False

islower()

文字列中のアルファベットが全て小文字の場合にTrue。アルファベット以外の数字や記号が含まれていても判定対象外で無視されるが、アルファベットがまったく含まれていないとFalse。

>>> print("ab".islower())
True
>>> print("aA".islower())
False
>>> print("a0+".islower())
True
>>> print("00".islower())
False

>>> print("ab".islower())

True

>>> print("aA".islower())

False

>>> print("a0+".islower())

True

>>> print("00".islower())

False

isupper()

文字列中のアルファベットが全て大文字の場合にTrue。アルファベット以外の数字や記号が含まれていても判定対象外。アルファベット以外の数字や記号が含まれていても判定対象外で無視されるが、アルファベットがまったく含まれていないとFalse。

>>> print("AB".isupper())
True
>>> print("Ab".isupper())
False
>>> print("A0+".isupper())
True
>>> print("00".isupper())
False

>>> print("AB".isupper())

True

>>> print("Ab".isupper())

False

>>> print("A0+".isupper())

True

>>> print("00".isupper())

False

isspace()

全ての文字がスペースの場合にTrue。

>>> print("  ".isspace())
True
>>> print(" a".isspace())
False

>>> print(" ".isspace())

True

>>> print(" a".isspace())

False

istitle()

文字列中の区切られた部分文字列がタイトルケースの場合にTrue。

>>> print("Chapter 1 - Firstcontact".istitle())
True
>>> print("Chapter 1 - firstcontact".istitle())
False
>>> print("Chapter 1 - FirstContact".istitle())
False

>>> print("Chapter 1 - Firstcontact".istitle())

True

>>> print("Chapter 1 - firstcontact".istitle())

False

>>> print("Chapter 1 - FirstContact".istitle())

False

検索

find/rfind

find()は指定した文字列を検索し、そのインデックスを返す。存在しない場合は-1が返される。検索範囲の指定はスライスと同じで[開始位置, 終了位置)。

index()も同じ使い方ができるが、存在しない場合にValueError: substring not foundが返される。

st = "abcdeabcde"

print(st.find("cd"))
# 2
# findは先頭に近いインデックスが返される

print(st.find("xy"))
# -1
# 見つからなかった場合は-1

print(st.find("cd", 3))
# 7
# 開始位置以降で最も早く合致したもの

print(st.find('c', 2, 8))
# 2
# 開始位置と終了位置の指定はスライスと同じ

st = "abcdeabcde"

print(st.find("cd"))

# 2

# findは先頭に近いインデックスが返される

print(st.find("xy"))

# -1

# 見つからなかった場合は-1

print(st.find("cd", 3))

# 7

# 開始位置以降で最も早く合致したもの

print(st.find('c', 2, 8))

# 2

# 開始位置と終了位置の指定はスライスと同じ

rfind()は文字列の後方から検索する。開始位置と終了位置の意味はスライスと同じだが、開始位置だけ指定すると、そこから文字列の後方が検索範囲となってしまう点に注意。

print(st.rfind("cd"))
# 7
# rfindは後端に近いインデックスが返される

print(st.rfind("xy"))
# -1
# 見つからなかった場合は-1

[print(st.rfind('c', i), end=' ') for i in range(len(st))]
# 7 7 7 7 7 7 7 7 -1 -1
# 開始位置は
print()

print(st.rfind('c', 1, 5))
# 2

print(st.rfind("cd"))

# 7

# rfindは後端に近いインデックスが返される

print(st.rfind("xy"))

# -1

# 見つからなかった場合は-1

[print(st.rfind('c', i), end=' ') for i in range(len(st))]

# 7 7 7 7 7 7 7 7 -1 -1

# 開始位置は

print()

print(st.rfind('c', 1, 5))

# 2

find/rfindとスライスでの範囲指定が違ってくる点に注意。

内容の変更

連結

+演算子で文字列を連結できる。

a = "My"
b = " Fair"
c = " Lady"
print(a + b + c)

# My Fair Lady

a = "My"

b = " Fair"

c = " Lady"

print(a + b + c)

# My Fair Lady

join()メソッドで、元の文字列オブジェクトを区切り文字にして、引数リストの各文字列要素を連結できる。

lyric = ["The", "Rain", "in", "Spain"]
print("--".join(lyric))

# The--Rain--in--Spain

lyric = ["The", "Rain", "in", "Spain"]

print("--".join(lyric))

# The--Rain--in--Spain

数値と文字列を連結する場合、Pythonでは自動変換されない。str()関数で明示的に文字列に変換する必要がある。

print("Python" + 3)
# TypeError: Can't convert 'int' object to str implicitly

print("Python" + str(3))
# Python3

print("Python" + 3)

# TypeError: Can't convert 'int' object to str implicitly

print("Python" + str(3))

# Python3

join()の方が推奨されているらしい。

split = '-'
lst = ["Bibbidi", "Bobbidi", "Boo"]
print(split.join(lst))

# Bibbidi-Bobbidi-Boo

split = '-'

lst = ["Bibbidi", "Bobbidi", "Boo"]

print(split.join(lst))

# Bibbidi-Bobbidi-Boo

繰り返し

*演算子で同じ文字列を複数回繰り返した文字列を得られる。

shout = "Wow"
print(shout * 4)

# WowWowWowWow

shout = "Wow"

print(shout * 4)

# WowWowWowWow

置き換え

replace(old, new[, count)メソッドは、部分文字列oldをnewで置き換える。countが指定されると、先頭からその個数分だけ置き換える。

置き換え前後の部分文字列の長さが違ってもよい。置き換え後に空文字列を指定すると、文字列の削除に使える。

replace()のほか、sub()関数(reパッケージ)、str.translate()関数も使える。

s = "abcdabcdabcdabcd"

print(s.replace("bc", "BC"))
# aBCdaBCdaBCdaBCd

print(s.replace("bc", "BC", 2))
# aBCdaBCdabcdabcd
# 先頭から2個のみ置き換え

print(s.replace("cd", "CDE"))
# abCDEabCDEabCDEabCDE
# 置き換え前後の部分文字列の長さが違ってもよい

print(s.replace('d', ''))
# abcabcabcabc
# 文字(列)削除に使う

s = "abcdabcdabcdabcd"

print(s.replace("bc", "BC"))

# aBCdaBCdaBCdaBCd

print(s.replace("bc", "BC", 2))

# aBCdaBCdabcdabcd

# 先頭から2個のみ置き換え

print(s.replace("cd", "CDE"))

# abCDEabCDEabCDEabCDE

# 置き換え前後の部分文字列の長さが違ってもよい

print(s.replace('d', ''))

# abcabcabcabc

# 文字(列)削除に使う

なお、部分文字列をスライスで取得した書式を使って文字列を代入することはできず、エラーとなる。

s = "0123456789"

s[3] = 'T'
# Traceback (most recent call last):
#  File "test.py", line 3, in <module>
#     s[3] = 'T'
# TypeError: 'str' object does not support item assignment

s = "0123456789"

s[3] = 'T'

# Traceback (most recent call last):

# File "test.py", line 3, in <module>

# s[3] = 'T'

# TypeError: 'str' object does not support item assignment

書式・整形

センタリング・左寄せ・右寄せ

center()、ljust()、rjust()の各メソッドで、元の文字列を指定した幅の中でセンタリング・左寄せ・右寄せできる。デフォルトでは空いた場所がスペース(‘ ‘)で埋められるが、その文字を指定することが可能。

s = "***"
print('|' + s.center(10) + '|')
print('|' + s.center(10, '-') + '|')
print('|' + s.ljust(10, '-') + '|')
print('|' + s.rjust(10, '-') + '|')

# |   ***    |
 |---***----|
# |***-------|
# |-------***|

print('|' + s.rjust(10, '--') + '|')
# Traceback (most recent call last):
#   File "test.py", line 6, in <module>
#    print('|' + s.rjust(10, '--') + '|')
# TypeError: The fill character must be exactly one character long

s = "***"

print('|' + s.center(10) + '|')

print('|' + s.center(10, '-') + '|')

print('|' + s.ljust(10, '-') + '|')

print('|' + s.rjust(10, '-') + '|')

# | *** |

|---***----|

# |***-------|

# |-------***|

print('|' + s.rjust(10, '--') + '|')

# Traceback (most recent call last):

# File "test.py", line 6, in <module>

# print('|' + s.rjust(10, '--') + '|')

# TypeError: The fill character must be exactly one character long

余白などの切り落とし

strip()、lstrip()、rstrip()各メソッドは、文字列の両端の指定文字を削除する。デフォルトでは空白が削除されるが、複数の文字を切り落とす対象として指定できる。

ただし、切り落とされるのは最も外側の文字列群だけであることに注意。

s = "   Python   "
print('|' + s.strip() + '|')
print('|' + s.lstrip() + '|')
print('|' + s.rstrip() + '|')
# |Python|
# |Python   |
# |   Python|

s = "  $  Python  $  "
print('|' + s.strip() + '|')
# |$  Python  $|
# 最も外側の該当文字だけが削除される

s = "--$$ Python--$$  "
print('|' + s.strip('- ') + '|')
# |$$ Python--$$|
# 複数文字を指定することも可能だが、これも最外側のみ

s = " Python "

print('|' + s.strip() + '|')

print('|' + s.lstrip() + '|')

print('|' + s.rstrip() + '|')

# |Python|

# |Python |

# | Python|

s = " $ Python $ "

print('|' + s.strip() + '|')

# |$ Python $|

# 最も外側の該当文字だけが削除される

s = "--$$ Python--$$ "

print('|' + s.strip('- ') + '|')

# |$$ Python--$$|

# 複数文字を指定することも可能だが、これも最外側のみ