かっこでグループ化する

例えば電話番号のうちで市外局番に別の処理をするなど、マッチしたテキストの一部を取り出したい場合があります。r'(\d\d\d)-(\d\d\d-\d\d\d\d)'のように丸かっこで囲むと正規表現文字列をグループ化できます。Matchオブジェクトのgroup()メソッドでマッチしたテキストをグループごとに取得できます。

正規表現文字列中の最初のかっこがグループ1で、2番目のかっこがグループ2です。整数の1や2をgroup()メソッドに渡すと、マッチしたテキストの対応する部分を取得できます。group()メソッドに0を渡すか何も渡さなければ、マッチしたテキスト全体が返されます。以下の式を対話型シェルに入力してみてください。

>>> import re
>>> phone_re = re.compile(r'(\d\d\d)-(\d\d\d-\d\d\d\d)')
>>> mo = phone_re.search('My number is 415-555-4242.')
>>> mo.group(1)  # マッチしたテキストの最初のグループを返す
'415'
>>> mo.group(2)  # マッチしたテキストの2番目のグループを返す
'555-4242'
>>> mo.group(0)  # マッチしたテキスト全体を返す
'415-555-4242'
>>> mo.group()  # これもマッチしたテキスト全体を返す
'415-555-4242'

すべてのグループをまとめて取得したければ、groups()メソッドを使います（複数形になっていることに注意してください）。

>>> mo.groups()
('415', '555-4242')
>>> area_code, main_number = mo.groups()
>>> print(area_code)
415
>>> print(main_number)
555-4242

mo.groups()は複数の値が中に入ったタプルを返しますから、area_code, main_number = mo.groups()の行のように、多重代入を使って複数の変数に代入できます。

エスケープ文字

丸かっこは正規表現の中でグループを作り、テキストのパターンであるとは解釈されません。そうすると、テキスト中で丸かっこにマッチさせたいときにはどうすればよいのでしょうか。例えば、マッチさせたい電話番号は、'(415) 555-4242'のように丸かっこ内に市外局番が書かれているかもしれません。

この場合、(と)をバックスラッシュでエスケープする必要があります。\(と\)で丸かっこをエスケープすれば、マッチさせたいパターンの一部であると解釈されます。以下の式を対話型シェルに入力してみてください。

>>> pattern = re.compile(r'(\(\d\d\d\)) (\d\d\d-\d\d\d\d)')
>>> mo = pattern.search('My phone number is (415) 555-4242.')
>>> mo.group(1)
'(415)'
>>> mo.group(2)
'555-4242'

re.compile()に渡されるraw文字列の\(と\)のエスケープ文字は、丸かっこにマッチします。正規表現では、以下の文字（記号）には特別な意味があります。

$ () * + - . ? [\] ^ {|}

これらの文字（記号）をテキストのパターンの一部にしたければ、バックスラッシュでエスケープする必要があります。

\$ \(\) \* \+ \- \. \? \[\\ \] \^ \{\| \}

正規表現でエスケープしていない丸かっこ(と)を、エスケープした丸かっこ\(と\)に取り違えていないかを、必ずダブルチェックしてください。“missing)”や“unbalanced parenthesis,”のようなエラーメッセージが表示されたら、以下の例のように、グループ化のかっこを閉じ忘れている可能性があります。

>>> import re
>>> re.compile(r'(\(Parentheses\)')
Traceback (most recent call last):
--snip--
re.error: missing), unterminated subpattern at position 0

エラーメッセージを読むと、文字列r'(\(Parentheses\)'のインデックス0にある開き丸かっこに対応する閉じ丸かっこが欠けていることがわかります。本章の最後のほうで説明するHumreモジュールを使うと、こうしたミスを防げます。

選択的なグループからのマッチ

正規表現では、パイプと呼ばれる|を選択演算子として用います。複数の表現のうちどれか一つにマッチさせられます。例えば、正規表現r'Cat|Dog'は、'Cat'か'Dog'のどちらかにマッチします。

正規表現の一部に選択演算子を使うことで、複数のパターンにマッチさせられます。例えば、'Caterpillar'、'Catastrophe'、'Catch'、'Category'という文字列にマッチさせたいとします。これらの文字列はすべてCatで始まっていますから、その共通部分を一度だけ指定できるとうれしいです。共通部分をくくりだして丸かっこ内でパイプを使うと、それを実現できます。以下の式を対話型シェルに入力してみてください。

>>> import re
>>> pattern = re.compile(r'Cat(erpillar|astrophe|ch|egory)')
>>> match = pattern.search('Catch me if you can.')
>>> match.group()
'Catch'
>>> match.group(1)
'ch'

match.group()メソッドを呼び出すと、マッチしたテキスト全体である'Catch'が返されます。match.group(1)はテキスト内で最初の丸かっこのグループでマッチした部分'ch'だけを返します。パイプとグループ化を活用すれば、正規表現でマッチさせたい選択的なパターンを指定できます。

パイプ記号にマッチさせたい場合は、\|のようにバックスラッシュでエスケープしてください。

すべてのマッチを返す

Patternオブジェクトには、search()メソッドのほかに、findall()メソッドがあります。search()は検索文字列が最初にマッチしたMatchオブジェクトを返すのに対し、findall()メソッドは検索文字列のすべてのマッチを返します。

findall()を使う際に覚えておくべきことが一つあります。。このメソッドは、正規表現にグループがなければ文字列のリストを返します。以下の式を対話型シェルに入力してみてください。

>>> import re
>>> pattern = re.compile(r'\d{3}-\d{3}-\d{4}')  # グループなしの正規表現
>>> pattern.findall('Cell: 415-555-9999 Work: 212-555-0000')
['415-555-9999', '212-555-0000']

正規表現にグループがあれば、findall()はタプルのリストを返します。それぞれのタプルが一つのマッチを表し、グループの文字列がタプルに含まれます。対話型シェルに次のコードを入力してこの動作を確かめてみましょう（今回は正規表現を丸かっこでグループ化しています）。

>>> import re
>>> pattern = re.compile(r'(\d{3})-(\d{3})-(\d{4})')  # グループありの正規表現
>>> pattern.findall('Cell: 415-555-9999 Work: 212-555-0000')
[('415', '555', '9999'), ('212', '555', '0000')]

findall()は重なる部分でマッチしないことも覚えておいてください。例えば、正規表現文字列r'\d{3}'で3つの数字にマッチさせると、'1234'の最初の3つの数字にマッチしますが、最後の3つの数字にはマッチしません。

>>> import re
>>> pattern = re.compile(r'\d{3}')
>>> pattern.findall('1234')
['123']
>>> pattern.findall('12345')
['123']
>>> pattern.findall('123456')
['123', '456']

'1234'の最初の3つの数字が '123'としてマッチするので、'234'はさらなるマッチ対象には含まれません。r'\d{3}'というパターンに合致するように見えてもこういう結果になります。

文字クラスと否定文字クラス

ここまでの例で見てきたようにマッチさせる一つの文字を指定することができますが、角かっこ内で複数の文字を指定することもできます。これを文字クラスと呼びます。例えば、[aeiouAEIOU]という文字クラスは、小文字と大文字のすべての母音にマッチします。a|e|i|o|u|A|E|I|O|Uと書くのと同じですが、文字クラスのほうが書きやすいです。以下の式を対話型シェルに入力してみてください。

>>> import re
>>> vowel_pattern = re.compile(r'[aeiouAEIOU]')
>>> vowel_pattern.findall('RoboCop eats BABY FOOD.')
['o', 'o', 'o', 'e', 'a', 'A', 'O', 'O']

ハイフンを使って文字や数字の範囲を含めることもできます。例えば、[a-zA-Z0-9]という文字クラスは、アルファベットのすべての小文字と大文字と数字にマッチします。

角かっこ内では正規表現で特別な意味を持つ記号が特別な意味に解釈されないことに注意してください。角かっこ内では丸かっこなどをエスケープしなくてもよいということです。例えば、文字クラス[()]は開き丸かっこと閉じ丸かっこのどちらかにマッチします。[\(\)]と書く必要はありません。

文字クラスの開き角かっこの直後にキャレット（^）を置くと、否定文字クラスを作れます。否定文字クラスは、その文字クラスに含まれない文字すべてにマッチします。対話型シェルで次のように入力してみてください。

>>> import re
>>> consonant_pattern = re.compile(r'[^aeiouAEIOU]')
>>> consonant_pattern.findall('RoboCop eats BABY FOOD.')
['R', 'b', 'C', 'p', ' ', 't', 's', ' ', 'B', 'B', 'Y', ' ', 'F', 'D', '.']

すべての母音にマッチするのではなく、すべての母音以外の文字にマッチします。スペースや改行や句読記号や数字にもマッチする点に注意してください。

短縮文字クラス

先の電話番号の正規表現の例では、\dが10進数のすべての数字を表すと説明しました。\dは0|1|2|3|4|5|6|7|8|9や[0-9]の短縮記法です。表9-1に示すように、短縮文字クラスはほかにもあります。

\dは数字にマッチして\wは数字と文字とアンダースコアにマッチしますが、文字だけにマッチする短縮文字クラスは存在しません。[a-zA-Z]という文字クラスを使うことができますが、これは'é'のようなアクセント文字や非ローマアルファベット文字にはマッチしません。また、バックスラッシュをエスケープするために、r'\d'のようにraw文字列を使うようにしてください。

対話型シェルで次のように入力してみてください。

>>> import re
>>> pattern = re.compile(r'\d+\s\w+')
>>> pattern.findall('12 drummers, 11 pipers, 10 lords, 9 ladies, 8 maids, 
7 swans, 6 geese, 5 rings, 4 birds, 3 hens, 2 doves, 1 partridge')
['12 drummers', '11 pipers', '10 lords', '9 ladies', '8 maids', '7 swans', '
6 geese', '5 rings', '4 birds', '3 hens', '2 doves', '1 partridge']

正規表現\d+\s\w+は、1つ以上の数字（\d+）にスペース（\s）が続き、さらに文字か数字かアンダースコア（\w+）が続くテキストにマッチします。findall()メソッドは正規表現のパターンにマッチする文字列をすべてリストで返します。

ドットで全てにマッチさせる

ドット（.）を正規表現文字列で使うと、改行文字以外のすべての文字にマッチします。対話型シェルで次のように入力してみてください。

>>> import re
>>> at_re = re.compile(r'.at')
>>> at_re.findall('The cat in the hat sat on the flat mat.')
['cat', 'hat', 'sat', 'lat', 'mat']

ドットは1文字だけにマッチするのを忘れないでください。上記の例flatがlatにしかマッチしないのはそのためです。ドットそのものにマッチさせたい場合は、\.のようにバックスラッシュでエスケープしてください。

マッチ対象に注意する

正規表現は、良くも悪くも、指定したパターンに正確にマッチします。ここでは文字クラスで誤解しやすい点を取り上げます。

• [A-Z]や[a-z]の文字クラスは、大文字あるいは小文字のアルファベットにマッチしますが、両方にマッチするわけではありません。大文字と小文字の両方にマッチさせるには[A-Za-z]と書きます。
• 文字クラス[A-Za-z]はアクセント記号のないアルファベットにマッチします。例えば、正規表現文字列r'First Name: ([A-Za-z]+)'は“First Name: ”のあとにアクセントのないアルファベットが来るものにマッチします。歌手Sinéad O’Connorの名前ではéの手前までしかマッチしません。グループ化されるのは'Sin'になります。
• 文字クラス\wは、アクセントのあるアルファベットや非アルファベットも含めて、すべての文字にマッチします。ただし、数字とアンダースコアにもマッチするので、r'First Name: (\w+)'は意図した以上のものにマッチする可能性があります。
• 文字クラス\wはすべての文字にマッチしますが、正規表現文字列r'Last Name: (\w+)'はSinéad O’Connorの名前のアポストロフィの手前までしかマッチしません。グループ化されるのは'O'になります。
• クォート記号（' " ‘ ’ “ ”）はそれぞれ別物として扱われるので、別々に指定しなければなりません。

現実世界のデータは複雑です。Sinéad O’Connorの名前をうまく扱えたとしても、Jean-Paul Sartreの名前ではハイフンがあるのでうまくいかないかもしれません。

もちろん、ソフトウェアが名前を正常に処理できないときには、名前が悪いのではなくソフトウェアが悪いです。人の名前が異常だと言うことはできません。https://www.kalzumeus.com/2010/06/17/falsehoods-programmers-believe-about-names/で読めるPatrick McKenzieの記事“Falsehoods Programmers Believe About Names”にもっと詳しく書かれています。この記事は、思い込みのせいでソフトウェアが日付、タイムゾーン、通貨、郵便番号、性別、空港コードなどをうまく処理できない、「プログラマの誤った信念」というジャンルを生み出しました。https://youtu.be/PYYfVqtcWQYでCarina C. Zona’s 2015 PyCon talkの“Schemas for the Real World”をご覧ください。

あってもなくてもマッチするパターン

指定したパターンがあってもなくてもマッチさせたいことが時々あります。質指定子に0または1の量を指定するということです。質指定子に?をつけるとその意味になります。対話型シェルで次のように入力してみてください。

>>> import re
>>> pattern = re.compile(r'42!?')
>>> pattern.search('42!')
<re.Match object; span=(0, 3), match='42!'>
>>> pattern.search('42')
<re.Match object; span=(0, 2), match='42'>

正規表現の?の部分は、!があってもなくてもいいことを示します。よって、これは42!（エクスクラメーションマークあり）と42（エクスクラメーションマークなし）の両方にマッチします。

そろそろお気づきの頃かと存じますが、正規表現の構文は特別な意味を持つ記号に依存しているので、読みづらいです。クエスチョンマーク（?）には特別な意味がありますが、エクスクラメーションマーク（!）には特別な意味がありません。r'42!?'は、'42'のあとに'!'があってもなくてもマッチするという意味になりますが、r'42?!'は'4'と'!'の間に'2'があってもなくてもマッチするという意味になります。

>>> import re
>>> pattern = re.compile(r'42?!')
>>> pattern.search('42!')
<re.Match object; span=(0, 3), match='42!'>
>>> pattern.search('4!')
<re.Match object; span=(0, 2), match='4!'>
>>> pattern.search('42') == None  # マッチしない
True

複数の文字があってもなくてもマッチさせるには、その複数の文字をグループ化して、その直後に?を置きます。先の電話番号の例なら、?を使って市外局番があってもなくてもマッチさせることができます。以下の式を対話型シェルに入力してみてください。

>>> pattern = re.compile(r'(\d{3}-)?\d{3}-\d{4}')
>>> match1 = pattern.search('My number is 415-555-4242')
>>> match1.group()
'415-555-4242'

>>> match2 = pattern.search('My number is 555-4242')
>>> match2.group()
'555-4242'

?は「このクエスチョンマークの直前のグループがあってもなくてもマッチする」という意味になります。

クエスチョンマークにマッチさせたければ、\?のようにエスケープしてください。

0個以上という量指定子

アスタリスク（*）は、「0個以上」を意味します。言い換えると、その直前の質指定子が、何回繰り返し出現しても構わないということです。まったくなくてもマッチしますし、何回繰り返されていてもマッチします。次の例を見てください。

>>> import re
>>> pattern = re.compile('Eggs(and spam)*')
>>> pattern.search('Eggs')
<re.Match object; span=(0, 4), match='Eggs'>
>>> pattern.search('Eggs and spam')
<re.Match object; span=(0, 13), match='Eggs and spam'>
>>> pattern.search('Eggs and spam and spam')
<re.Match object; span=(0, 22), match='Eggs and spam and spam'>
>>> pattern.search('Eggs and spam and spam and spam')
<re.Match object; span=(0, 31), match='Eggs and spam and spam and spam'>

文字列の'Eggs'という部分は1回だけ現れますが、それに続く' and spam'という部分は何回出現しても構いませんし、出現しなくても構いません。

アスタリスクにマッチさせたければ、\*のようにバックスラッシュでエスケープしてください。

1個以上という量指定子

*は「0個以上」を意味しましたが、プラス（+）は「1個以上」を意味します。出現しなくてもマッチするアスタリスクとは異なり、プラスはその直前の質指定子が少なくとも1回は出現しなければマッチしません。出現するかしないかが選択的ではないということです。対話型シェルに次の内容を入力して、先のアスタリスクの例と比べてください。

>>> pattern = re.compile('Eggs(and spam)+')
>>> pattern.search('Eggs and spam')
<re.Match object; span=(0, 13), match='Eggs and spam'>
>>> pattern.search('Eggs and spam and spam')
<re.Match object; span=(0, 22), match='Eggs and spam and spam'>
>>> pattern.search('Eggs and spam and spam and spam')
<re.Match object; span=(0, 31), match='Eggs and spam and spam and spam'>

正規表現'Eggs(and spam)+'は'Eggs'にはマッチしません。プラスは少なくとも1回の' and spam'にマッチします。

正規表現文字列内で量指定子を使うときには、グループ全体に適用するために、丸かっこを使ってグループ化することがよくあるでしょう。例えば、モールス信号のドットとダッシュの組み合わせをr'(\.|\-)+'でマッチさせられます（この表現は正しくないモールス信号にもマッチします）。

プラス記号にマッチさせたければ、\+のようにバックスラッシュでエスケープしてください。

指定した回数のマッチ

繰り返し回数を指定してマッチさせたければ、その回数を波かっこで囲みます。例えば、正規表現(Ha){3}は'HaHaHa'にマッチしますが、(Ha)が2回しか繰り返されていない'HaHa'にはマッチしません。

波かっこ内に一つの数値で回数を指定するのではなく、最小回数とカンマと最大回数で範囲を指定することもできます。例えば、(Ha){3,5}は'HaHaHa'、'HaHaHaHa'、'HaHaHaHaHa'にマッチします。

最小回数と最大回数は省略可能です。例えば、(Ha){3,}は(Ha)の3回以上の繰り返しにマッチし、(Ha){,5}は5回以下の繰り返しにマッチします。波かっこを使うと正規表現を短く書けます。この2つの正規表現は同じパターンを示しています。

(Ha){3}
HaHaHa

この2つも同じです。

(Ha){3,5}
(HaHaHa)|(HaHaHaHa)|(HaHaHaHaHa)

以下の式を対話型シェルに入力してみてください。

>>> import re
>>> haRegex = re.compile(r'(Ha){3}')
>>> match1 = haRegex.search('HaHaHa')
>>> match1.group()
'HaHaHa'

>>> match = haRegex.search('HaHa')
>>> match == None
True

(Ha){3}は'HaHaHa'にマッチしますが、'Ha'にはマッチしません。'HaHa'にマッチしないのでsearch()はNoneを返します。

波かっこの量指定子の構文は、Pythonのスライスの構文（例：'Hello, world!'[3:5]が'lo'に評価されます）に似ています。しかし大きな違いがあります。正規表現の量指定子は、コロンではなくカンマで2つの数値を区切ります。また、量指定子の2つ目の数値は含まれます。'(Ha){3,5}'は'(Ha)'質指定子が5回繰り返されるものも含みます。

すべてにマッチさせる

すべてにマッチさせたい場面が時々あります。例えば、'First Name:'のあとに何らかのテキストがあり、続けて'Last Name:'のあとに何らかのテキストがあるときなどです。「何でも」を表すのにドットスター（.*）を使えます。ドットは「改行以外のすべての文字」という意味ですし、スター（アスタリスク）は「0個以上」という意味です。

以下の式を対話型シェルに入力してみてください。

>>> import re
>>> name_pattern = re.compile(r'First Name: (.*) Last Name: (.*)')
>>> name_match = name_pattern.search('First Name: Al Last Name: Sweigart')
>>> name_match.group(1)
'Al'
>>> name_match.group(2)
'Sweigart'

ドットスターは貪欲です。できる限り長いテキストにマッチします。非貪欲にしたければ、ドットスターのあとにクエスチョンマークをつけてください（.*?）。波かっこのあとにクエスチョンマークをつけたときと同じように、非貪欲マッチにできます。

以下の内容を対話型シェルに入力し、貪欲と非貪欲の違いを確認してください。

>>> import re
>>> lazy_pattern = re.compile(r'<.*?>')
>>> match1 = lazy_pattern.search('<To serve man> for dinner.>')
>>> match1.group()
'<To serve man>'

>>> greedy_re = re.compile(r'<.*>')
>>> match2 = greedy_re.search('<To serve man> for dinner.>')
>>> match2.group()
'<To serve man> for dinner.>'

どちらの正規表現も、大まかに言うと、「小なり記号と大なり記号にマッチして、間に何が入っていてもよい」という内容になります。しかし、文字列'<To serve man> for dinner.>'には、大なり記号に関して2つの可能性があります。非貪欲マッチでは、可能な限り短い文字列である'<To serve man>'にマッチします。貪欲マッチでは、可能な限り長い文字列である'<To serve man> for dinner.>'にマッチします。

改行文字のマッチ

.*のドットは改行以外のすべてにマッチします。re.compile()の第二引数にre.DOTALLを渡すと、ドットが改行を含めてすべての文字にマッチします。

以下の式を対話型シェルに入力してみてください。

>>> import re
>>> no_newline_re = re.compile('.*')
>>> no_newline_re.search('Serve the public trust.\nProtect the innocent. 
\nUphold the law.').group()
'Serve the public trust.'

>>> newline_re = re.compile('.*', re.DOTALL)
>>> newline_re.search('Serve the public trust.\nProtect the innocent. 
\nUphold the law.').group()
'Serve the public trust.\nProtect the innocent.\nUphold the law.'

正規表現no_newline_reは、re.compile()にre.DOTALLを渡していないので、最初の改行までのすべてにマッチします。他方で、newline_reはre.compile()にre.DOTALLを渡しているので、すべてにマッチします。newline_re.search()を呼び出すと改行文字を含めて文字列全体にマッチするのはそのためです。

ステップ1：電話番号用の正規表現の作成

まず、電話番号用の正規表現を作成します。新しいファイルエディタウィンドウを開いて、以下のコードをphoneAndEmail.pyという名前で保存してください。

import pyperclip, re

phone_re = re.compile(r'''(
    (\d{3}|\(\d{3}\))?# 市外局番
    (\s|-|\.)?# 区切り
    (\d{3})  # 最初の3桁の数字
    (\s|-|\.)  # 区切り
    (\d{4})  # 最後の4桁の数字
    (\s*(ext|x|ext\.)\s*(\d{2,5}))?# 内線番号
    )''', re.VERBOSE)

# TODO：メールアドレス用の正規表現を作成する

# TODO：クリップボードのテキストでマッチさせる

# TODO: 結果をクリップボードに貼り付ける

TODOコメントはプログラムの骨組みです。実際にその部分のコードを書いたらコメントは削除します。

電話番号で市外局番を書くこともあれば書かないこともあるので、市外局番をグループ化してクエスチョンマークをつけました。市外局番は3桁なので（訳注：日本の市外局番は3桁とは限りません）、\d{3}です。市外局番がかっこ内に書かれている場合は\(\d{3}\)です。これらをパイプでつなぎます。(\d{3}|\(\d{3}\))?が何にマッチするのかを思い出せるように、複数行文字列の正規表現中に# 市外局番というコメントを入れておきます。

電話番号の区切りとなる可能性があるのは、スペース（\s）かハイフン（-）かピリオド（.）なので、これらをパイプでつなげます。その次の部分は見たままです。3桁の数字、区切り、4桁の数字です。最後の部分は内線番号です。extかxかext.にスペースを入れて2〜5桁の数字が続く可能性があります。

注記

グループ化のかっこ()とエスケープしたかっこ\(\)が混在している正規表現では混乱しがちです。“missing), unterminated subpattern”エラーメッセージが表示されたら、正しく表現できているかダブルチェックしてください。

ステップ2：メールアドレス用の正規表現の作成

メールアドレス用の正規表現も必要です。以下のようなコードになります。

import pyperclip, re

phone_re = re.compile(r'''(
--snip--

# メールアドレス用の正規表現
email_re = re.compile(r'''(
  ❶ [a-zA-Z0-9._%+-]+  # ユーザー名
  ❷ @  # @記号
  ❸ [a-zA-Z0-9.-]+  # ドメイン名
    (\.[a-zA-Z]{2,4})  # ドット何とか
    )''', re.VERBOSE)

# TODO：クリップボードのテキストでマッチさせる

# TODO: 結果をクリップボードに貼り付ける

メールアドレスのユーザー名の部分(❶)は、小文字と大文字のアルファベット、数字、ドット、アンダースコア、パーセント記号、プラス記号、ハイフンの中からなる1文字以上の文字列です。文字クラス[a-zA-Z0-9._%+-]でそれを表します。

ドメインとユーザー名は@で区切られます(❷)。ドメイン名(❸)に使える文字種はユーザー名に使える文字種よりも少ないです。アルファベット、数字、ピリオド、ハイフンだけで、[a-zA-Z0-9.-]です。最後はドットコム的な部分で（技術的にはトップレベルドメインと呼ばれます）、ドット何とかという形です。

メールアドレスの形式には奇妙なルールがたくさんあり、この正規表現ですべてのあり得るメールアドレスにマッチするわけではありませんが、探している典型的なメールアドレスにはほぼマッチするでしょう。

ステップ3：クリップボードのテキストからすべてのマッチを見つける

電話番号用とメールアドレス用の正規表現を作成しましたから、クリップボードからすべてのマッチを見つけるという面倒な作業をPythonのreモジュールにやらせましょう。pyperclip.paste()関数でクリップボードのテキストの文字列値を取得し、正規表現のfindall()メソッドでマッチしたリストをタプルで返します。

以下のようなコードになります。

import pyperclip, re

phone_re = re.compile(r'''(
--snip--

# クリップボードのテキストでマッチさせる
text = str(pyperclip.paste())

❶ matches = []
❷ for groups in phone_re.findall(text):
    phone_num = '-'.join([groups[1], groups[3], groups[5]])
    if groups[6] != '':
        phone_num += ' x' + groups[6]
    matches.append(phone_num)
❸ for groups in email_re.findall(text):
    matches.append(groups[0])

# TODO：結果をクリップボードに貼り付ける

マッチごとに一つのタプルがあり、各タプルには正規表現のそれぞれのグループの文字列が含まれています。グループ0は正規表現全体ですから、タプルのインデックス0が対象になります。

matchesという名前のリスト変数にマッチした結果を格納します(❶)。空リストで始めて2つのforループに入ります。メールアドレスに関しては、マッチごとにグループ0を追加します(❸)。電話番号に関しては、単純にグループ0を追加するわけにはいきません。いくつかの形式の電話番号を検出しているので、一つの標準化した形式でリストに追加します。変数phone_numには、マッチした文字列のグループ1、3、5、6から組み立てた文字列を格納します(❷)。（これらのグループは、市外局番、3桁の数字、4桁の数字、内線番号です。）

ステップ4：すべてのマッチを一つの文字列にする

matchesというリストの中にメールアドレスと電話番号の文字列を準備できましたから、次はこれらをクリップボードに貼り付けます。pyperclip.copy()関数は、文字列のリストではなく、一つの文字列値を取るので、matchesについてjoin()メソッドを呼び出します。

以下のようなコードになります。

import pyperclip, re

phone_re = re.compile(r'''(
--snip--
for groups in email_re.findall(text):
    matches.append(groups[0])

# 結果をクリップボードに貼り付ける
if len(matches) > 0:
    pyperclip.copy('\n'.join(matches))
    print('Copied to clipboard:')
    print('\n'.join(matches))
else:
    print('No phone numbers or email addresses found.')

プログラムの動作を見えやすくするために、マッチしたものをターミナルウィンドウに表示します。電話番号とメールアドレスが一つも見つからなければ、そのことをユーザーに知らせます。

このプログラムを試すには、https://nostarch.com/contactusのNo Starch Press のお問い合わせページを開き、CTRL-Aを押してそのページのすべてのテキストを選択して、CTRL-Cを押してクリップボードにコピーしてください。このプログラムを実行すると、以下のように表示されるはずです。

Copied to clipboard:
800-555-7240
415-555-9900
415-555-9950
info@nostarch.com
media@nostarch.com
academic@nostarch.com
info@nostarch.com

このプログラムを改造すれば、メーリングリストのアドレス、ソーシャルメディアのハンドルネーム、その他のテキストパターンを探すことができます。

似たようなプログラムのアイデア

テキストのパターンを指定できると（sub()メソッドで置換もできます）、さまざまなアプリケーションを作成できる可能性に開かれます。例えば、以下の内容が考えられます。

• http://またはhttps://で始まるURLを探す
• （3/14/2030や03-14-2030や2030/3/14のような）日付のフォーマットを標準的なフォーマットに統一する
• 社会保障番号やクレジットカード番号のような機密情報を取り除く
• 単語と単語の間の複数スペースや重複やエクスクラメーションマークの繰り返しなど、よくあるタイプミスを発見する

強力なパスワードであることの検証

正規表現を使って、渡されたパスワード文字列が強力か確かめる関数を書いてください。ここでの強力なパスワードとは、8文字以上の長さで、大文字と小文字と数字をすべて含むパスワードだとします。ヒント：すべてのルールを検証する一つの正規表現を書くよりも、複数の正規表現を書くほうが簡単です。

正規表現バージョンのstrip()メソッド

文字列を引数に取り、文字列メソッドstrip()と同じ動作をする関数を書いてください。対象とする文字列以外の引数が渡されなければ（第一引数しか存在しなければ）、文字列の両端から空白文字を取り除いてください。第二引数が存在すれば、第二引数で指定された文字を取り除いてください。