Python バックエンド プログラム言語

Pythonの正規表現で使える文字列パターンを紹介。

2020年5月15日

こんにちは!TodoONadaの土門(@daikidomon)です。nin

Pythonで使える正規表現の文字列パター

を紹介したいと思います。

データ操作やスクレイピングなどで必ず使用するテクニックになります。

 

以下に正規表現のまとめ記事を書きましたので、チートシート的に使用していただけばと思います。

Pythonの正規表現でよく使うパターンのテンプレート

こんにちは!TodoONadaの土門(@shimidai2100)です。 Pythonの正規表現でよく使うパターンをまと ...

続きを見る

正規表現とは?

正規表現とは文字列の集合で一つの種類の文字列を表現する方法であります。

そして、正規表現は主にそのパターンのの検索、置換、インプットの検証などでよく使います。

実際プログラミング言語の間に正規表現の違い(特定のプログラミング言語に存在するがと特定のプログラミング言語に存在しない)がありますが、

ライブラリによって正規表現を使えます(使える正規表現は確認しなければなりません)。

正規表現は現在サーチエンジン、字句解析、AWK(オーク)などでよく使われております。

説明正規表現
文字列の先頭^ または \A
文字列の末尾$ または \z
任意の一文字.
0回以上の繰り返し*
1回以上の繰り返し+
0回または1回?
m回の繰り返し{m}
m〜n回の繰り返し{m,n}
集合([a-z]など)[]
和集合(または)|
グループ化()
タブ\t
改行。CR(Carriage Return:0x0D)\r
改行。LF(Line Feed:0x0A)\n
改行。Windows\r\n
単語の先頭か末尾にマッチ\b
単語の先頭か末尾以外にマッチ\B
任意の数字\d または [0-9]
任意の数字以外\D または [^0-9]
任意の空白文字\s または [ \t\f\r\n]
任意の空白文字以外\S
任意の英数字(アルファベット、アンダーバー、数字)\w
任意の英数字以外(アルファベット、アンダーバー、数字以外の文字 )\W または [a-zA-Z_0-9]

文字列の先頭:^ または \A

以下がサンプルになります。

import re

begin_str_one = "Google is this"
begin_str_two = "This is Google"

pattern_one = "^Google"
pattern_two = r"\AGoogle"

pattern_one_matchone = re.search(pattern_one,begin_str_one)
pattern_one_matchtwo = re.search(pattern_one,begin_str_two)

print(pattern_one_matchone)
# <_sre.SRE_Match object; span=(0, 6), match='Google'>

print(pattern_one_matchtwo)
# None


pattern_two_matchone = re.search(pattern_two,begin_str_one)
pattern_two_matchtwo = re.search(pattern_two,begin_str_two)

print(pattern_two_matchone)
# <_sre.SRE_Match object; span=(0, 6), match='Google'>

print(pattern_two_matchtwo)
# None

文字列の末尾:$ または \Z

以下がサンプルになります。

import re

begin_str_one = "Google is this"
begin_str_two = "This is Google"

pattern_one = "Google$"
pattern_two = r"Google\Z"

pattern_one_matchone = re.search(pattern_one,begin_str_one)
pattern_one_matchtwo = re.search(pattern_one,begin_str_two)

print(pattern_one_matchone)
# None

print(pattern_one_matchtwo)
# <_sre.SRE_Match object; span=(8, 14), match='Google'>


pattern_two_matchone = re.search(pattern_two,begin_str_one)
pattern_two_matchtwo = re.search(pattern_two,begin_str_two)


print(pattern_two_matchone)
# None

print(pattern_two_matchtwo)
# <_sre.SRE_Match object; span=(8, 14), match='Google'>

任意の一文字:.

以下がサンプルになります。

import re

char_one = 'A'
char_two = 'a'
char_three = 'あ'

pattern = "."

match_one = re.search(pattern,char_one)
match_two = re.search(pattern,char_two)
match_three = re.search(pattern,char_three)

print(match_one)
# <re.Match object; span=(0, 1), match='A'>

print(match_two)
# <re.Match object; span=(0, 1), match='a'>

print(match_three)
# <re.Match object; span=(0, 1), match='あ'>

0回以上の繰り返し:*

以下がサンプルになります。

import re

char_one = 'yahoo'
char_two = 'yehoo'
char_three = 'google'

pattern = "ya*"

match_one = re.search(pattern,char_one)
match_two = re.search(pattern,char_two)
match_three = re.search(pattern,char_three)

print(match_one)
# <_sre.SRE_Match object; span=(0, 2), match='ya'>
print(match_two)
# <_sre.SRE_Match object; span=(0, 1), match='y'>

print(match_three)
# None

1回以上の繰り返し:∔

以下がサンプルになります。

import re

char_one = 'abc'
char_two = 'abbbbc'
char_three = 'ac'

pattern = "ab+"

match_one = re.search(pattern,char_one)
match_two = re.search(pattern,char_two)
match_three = re.search(pattern,char_three)

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

print(match_two)
# <_sre.SRE_Match object; span=(0, 5), match='abbbb'>

print(match_three)
# None

0回または1回:?

以下がサンプルになります。

import re

char_one = 'ac'
char_two = 'abc'
char_three = 'abbc'

pattern = "ab?c"

match_one = re.search(pattern,char_one)
match_two = re.search(pattern,char_two)
match_three = re.search(pattern,char_three)

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

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

print(match_three)
# None

m回の繰り返し:{m}

以下がサンプルになります。

import re

char_one = 'aaa'
char_two = 'aaaaaa'

pattern_one = "a{3}"
pattern_two = "^a{3}$"

match_one_one = re.search(pattern_one,char_one)
match_two_one = re.search(pattern_one,char_two)

match_one_two = re.search(pattern_two,char_one)
match_two_two = re.search(pattern_two,char_two)

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

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

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

print(match_two_two)
# None

m〜n回の繰り返し:{m,n}

以下がサンプルになります。

import re

char_one = 'aaa'
char_two = 'aaaaa'
char_three = 'aaaaaaaaaa'

pattern_one = "a{3,5}"
pattern_two = "^a{3,5}$"

match_one_one = re.search(pattern_one,char_one)
match_two_one = re.search(pattern_one,char_two)
match_three_one = re.search(pattern_one,char_three)

match_one_two = re.search(pattern_two,char_one)
match_two_two = re.search(pattern_two,char_two)
match_three_two = re.search(pattern_two,char_three)

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

print(match_two_one)
# <_sre.SRE_Match object; span=(0, 5), match='aaaaa'>

print(match_three_one)
# <_sre.SRE_Match object; span=(0, 5), match='aaaaa'>

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

print(match_two_two)
# <_sre.SRE_Match object; span=(0, 5), match='aaaaa'>

print(match_three_two)
# None

集合([a-z]など):[]

以下がサンプルになります。

import re

char_one = 'apple'
char_two = 'nothing'
char_three = '1234567890'


pattern_one = "[a-z]"
pattern_two = "[ae]"

match_one_one = re.search(pattern_one,char_one)
match_two_one = re.search(pattern_one,char_two)
match_three_one = re.search(pattern_one,char_three)

match_one_two = re.search(pattern_two,char_one)
match_two_two = re.search(pattern_two,char_two)
match_three_two = re.search(pattern_two,char_three)

print(match_one_one)
# <_sre.SRE_Match object; span=(0, 1), match='a'>

print(match_two_one)
# <_sre.SRE_Match object; span=(0, 1), match='n'>

print(match_three_one)
# None

print(match_one_two)
# <_sre.SRE_Match object; span=(0, 1), match='a'>

print(match_two_two)
# None

print(match_three_two)
# None

和集合(または):|

以下がサンプルになります。

import re

char_one = 'a'
char_two = 'b'
char_three = 'c'

pattern = "a|b"

match_one = re.search(pattern,char_one)
match_two = re.search(pattern,char_two)
match_three = re.search(pattern,char_three)

print(match_one)
# <_sre.SRE_Match object; span=(0, 1), match='a'>

print(match_two)
# <_sre.SRE_Match object; span=(0, 1), match='b'>

print(match_three)
# None

グループ化:()

以下がサンプルになります。

import re

char_one = 'abc'
char_two = 'abcabc'
char_three = 'ab cab c'

pattern = "(abc)"

match_one = re.search(pattern,char_one)
match_two = re.search(pattern,char_two)
match_three = re.search(pattern,char_three)

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

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

print(match_three)
# None

タブ:\t

以下がサンプルになります。

import re

char_one = 'a\tb'
char_two = 'ab'

pattern = r"a\tb"

match_one = re.search(pattern,char_one)
match_two = re.search(pattern,char_two)

print(char_one)
# a       b

print(match_one)

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

print(match_two)
# None

改行コード:\r、\n、\r\n

改行コードはOSや環境によって異なりますので注意してください。

  • CR:復帰を意味します。キャレットを左端の位置に戻すことでMacOSで利用されます。
  • LF:改行。キャレットを新しい行に移動することを意味し、Linuxで利用します。最も一般的です。
  • CRLF:復帰+改行を意味します。Windows環境で利用されます。

以下がサンプルになります。

import re

char_one = 'b'
char_two = 'a\rb'

pattern = "a\rb"

match_one = re.search(pattern,char_one)
match_two = re.search(pattern,char_two)

print(char_one)
# b

print(match_one)
# None

print(match_two)
# <re.Match object; span=(0, 3), match='a\rb'>

# ====================================================

char_one = 'b'
char_two = 'a\nb'

pattern = "a\nb"

match_one = re.search(pattern,char_one)
match_two = re.search(pattern,char_two)

print(char_one)
# b

print(match_one)
# None

print(match_two)
# <re.Match object; span=(0, 3), match='a\nb'>

単語の先頭か末尾にマッチ:\b

以下がサンプルになります。

import re

char_one = 'google is good'
char_two = 'googleisgood'

pattern = r"\bgoogle\b"

match_one = re.search(pattern,char_one)
match_two = re.search(pattern,char_two)


print(match_one)
# <_sre.SRE_Match object; span=(0, 6), match='google'>

print(match_two)
# None

単語の先頭か末尾以外にマッチ:\B

以下がサンプルになります。

import re

char_one = 'google is good'
char_two = 'googleisgood'

pattern = r"google\B"

match_one = re.search(pattern,char_one)
match_two = re.search(pattern,char_two)


print(match_one)
# None

print(match_two)
# <_sre.SRE_Match object; span=(0, 6), match='google'>

任意の数字:\d または [0-9]

以下がサンプルになります。

import re

char_one = 'apple'
char_two = '12345'

pattern_one = r"\d"
pattern_two = "[0-9]"

match_one_one = re.search(pattern_one,char_one)
match_two_one = re.search(pattern_one,char_two)

match_one_two = re.search(pattern_two,char_one)
match_two_two = re.search(pattern_two,char_two)

print(match_one_one)
# None

print(match_two_one)
# <_sre.SRE_Match object; span=(0, 1), match='1'>

print(match_one_two)
# None

print(match_two_two)
# <_sre.SRE_Match object; span=(0, 1), match='1'>

 

任意の数字以外:\D または[^0-9]

以下がサンプルになります。

import re

char_one = 'apple'
char_two = '12345'

pattern_one = r"\D"
pattern_two = "[^0-9]"

match_one_one = re.search(pattern_one,char_one)
match_two_one = re.search(pattern_one,char_two)

match_one_two = re.search(pattern_two,char_one)
match_two_two = re.search(pattern_two,char_two)

print(match_one_one)
# <_sre.SRE_Match object; span=(0, 1), match='a'>

print(match_two_one)
# None

print(match_one_two)
# <_sre.SRE_Match object; span=(0, 1), match='a'>

print(match_two_two)
# None

 

 任意の空白文字  \s

空白文字(半角スペース、\t、\n、\r、\f)をまとめてマッチすることができます。

以下がサンプルになります。

import re

char_one = 'apple\tisdelicious'
char_two = 'apple\fisdelicious'
char_three = 'apple\risdelicious'
char_four = 'apple\nisdelicious'
char_five = 'appleisdelicious'
char_six ='apple is delicious'

pattern = r"\s"

match_one = re.search(pattern,char_one)
match_two = re.search(pattern,char_two)
match_three = re.search(pattern,char_three)
match_four = re.search(pattern,char_four)
match_five = re.search(pattern,char_five)
match_six = re.search(pattern,char_six)


print(match_one)
# <_sre.SRE_Match object; span=(5, 6), match='\t'>

print(match_two)
# <_sre.SRE_Match object; span=(5, 6), match='\x0c'>

print(match_three)
# <_sre.SRE_Match object; span=(5, 6), match='\r'>

print(match_four)
# <_sre.SRE_Match object; span=(5, 6), match='\n'>

print(match_five)
# None

print(match_six)
# <_sre.SRE_Match object; span=(5, 6), match=' '>

任意の空白文字以外:\S

空白文字(半角スペース、\t、\n、\r、\f)以外をまとめてマッチすることができます。

以下がサンプルになります。

import re

char_one = '\t'
char_two = '\f'
char_three = '\r'
char_four = '\n'
char_five = ' '
char_six ='appleisdelicious'

pattern = r"\S"

match_one = re.search(pattern,char_one)
match_two = re.search(pattern,char_two)
match_three = re.search(pattern,char_three)
match_four = re.search(pattern,char_four)
match_five = re.search(pattern,char_five)
match_six = re.search(pattern,char_six)

print(match_one)
# None

print(match_two)
# None

print(match_three)
# None

print(match_four)
# None

print(match_five)
# None

print(match_six)
# <_sre.SRE_Match object; span=(0, 1), match='a'>

任意の英数字(アルファベット、アンダーバー、数字):\w

以下がサンプルになります。

import re

char_one = 'apple'
char_two = 'Apple'
char_three = '12345'
char_four = '_'
char_five = ' '
char_six ='%$'

pattern = r"\w"

match_one = re.search(pattern,char_one)
match_two = re.search(pattern,char_two)
match_three = re.search(pattern,char_three)
match_four = re.search(pattern,char_four)
match_five = re.search(pattern,char_five)
match_six = re.search(pattern,char_six)

print(match_one)
# <_sre.SRE_Match object; span=(0, 1), match='a'>

print(match_two)
# <_sre.SRE_Match object; span=(0, 1), match='A'>

print(match_three)
# <_sre.SRE_Match object; span=(0, 1), match='1'>

print(match_four)
# <_sre.SRE_Match object; span=(0, 1), match='_'>

print(match_five)
# None

print(match_six)
# None

任意の英数字以外(アルファベット、アンダーバー、数字以外の文字 ):\W

以下がサンプルになります。

import re

char_one = 'apple'
char_two = 'Apple'
char_three = '12345'
char_four = '_'
char_five = ' '
char_six ='%$'

pattern = r"\W"

match_one = re.search(pattern,char_one)
match_two = re.search(pattern,char_two)
match_three = re.search(pattern,char_three)
match_four = re.search(pattern,char_four)
match_five = re.search(pattern,char_five)
match_six = re.search(pattern,char_six)

print(match_one)
# None

print(match_two)
# None

print(match_three)
# None

print(match_four)
# None

print(match_five)
# <_sre.SRE_Match object; span=(0, 1), match=' '>

print(match_six)
# <_sre.SRE_Match object; span=(0, 1), match='%'>

 

関連記事

-Python, バックエンド, プログラム言語

Copyright© スタートアップIT企業社長のブログ , 2020 All Rights Reserved.