6.2. "re" --- 正規表現操作
**************************

**ソースコード:** Lib/re.py

======================================================================

このモジュールは、Perl などと同様の正規表現マッチング操作を提供してい
ます。

パターンと文字列には Unicode 文字列 ("str") および 8 ビット文字列
("bytes") が使用できます。しかし、Unicode 文字列と8ビット文字列の混在
はできません。すなわち、Unicode 文字列をバイト列のパターンでマッチング
したり、その逆はできません。同様に、置き換え時の置換文字列はパターンお
よび検索文字列と同じ型でなくてはなりません。

正規表現では、特殊な形式を表したり、特殊文字の持つ特別な意味を呼び出さ
ずにその特殊な文字を使えるようにするために、バックスラッシュ文字
("'\'") を使います。こうしたバックスラッシュの使い方は、 Python の文字
列リテラルにおける同じバックスラッシュ文字と衝突を起こします。例えば、
バックスラッシュ自体にマッチさせるには、パターン文字列として "'\\\\'"
と書かなければなりません、というのも、正規表現は "\\" でなければならず
、さらに正規な Python 文字列リテラルでは各々のバックスラッシュを "\\"
と表現せねばならないからです。

正規表現パターンに Python の raw string 記法を使えばこの問題を解決でき
ます。 "'r'" を前置した文字列リテラル内ではバックスラッシュを特別扱い
しません。従って、 ""\n"" が改行一文字の入った文字列になるのに対して、
"r"\n"" は "'\'" と "'n'" という二つの文字の入った文字列になります。通
常、 Python コード中では、パターンをこの raw string 記法を使って表現し
ます。

大抵の正規表現操作が、モジュールレベルの関数と、 コンパイル済み正規表
現 のメソッドとして提供されることに注意して下さい。関数は正規表現オブ
ジェクトのコンパイルを必要としない近道ですが、いくつかのチューニング変
数を失います。

参考:

  サードパーティの regex モジュールは、標準ライブラリの "re" モジュー
  ルと互換な API を持ち、追加の機能とより徹底した Unicode サポートを提
  供します。


6.2.1. 正規表現のシンタックス
=============================

正規表現 (すなわち RE) は、表現にマッチ (match) する文字列の集合を表し
ています。このモジュールの関数を使えば、ある文字列が指定の正規表現にマ
ッチするか (または指定の正規表現がある文字列にマッチするか、つまりは同
じことですが) を検査できます。

正規表現を連結すると新しい正規表現を作れます。*A* と *B* がともに正規
表現であれば *AB* も正規表現です。一般的に、文字列 *p* が *A* とマッチ
し、別の文字列 *q* が *B* とマッチすれば、文字列 *pq* は AB にマッチし
ます。ただし、この状況が成り立つのは、*A* と *B* との間に境界条件があ
る場合や、番号付けされたグループ参照のような、優先度の低い演算を *A*
や *B* が含まない場合だけです。このようにして、ここで述べるような、よ
り簡単でプリミティブな正規表現から、複雑な正規表現を容易に構築できます
。正規表現に関する理論と実装の詳細については Friedl 本 [Frie09] か、コ
ンパイラの構築に関するテキストを参照してください。

以下で正規表現の形式に関する簡単な説明をしておきます。より詳細な情報や
よりやさしい説明に関しては、 正規表現 HOWTO を参照してください。

正規表現には、特殊文字と通常文字の両方を含められます。 "'A'" 、 "'a'"
、あるいは "'0'" のようなほとんどの通常文字は最も簡単な正規表現になり
ます。こうした文字は、単純にその文字自体にマッチします。通常の文字は連
結できるので、 "last" は文字列 "'last'" とマッチします。 (この節の以降
の説明では、正規表現を引用符を使わずに "この表示スタイル: special
style" で書き、マッチ対象の文字列は、 "'引用符で括って'" 書きます。)

"'|'" や "'('" といったいくつかの文字は特殊文字です。特殊文字は通常の
文字の種別を表したり、あるいは特殊文字の周辺にある通常の文字に対する解
釈方法に影響します。

繰り返しの修飾子 ("*", "+", "?", "{m,n}" など) は直接入れ子にはできま
せん。 これによって、非貪欲な修飾子の接尾辞 "?" や他の実装での他の修飾
子についての曖昧さを回避しています。 繰り返しのある正規表現の外側にさ
らに繰り返しを適用するには丸括弧が使えます。 例えば、正規表現
"(?:a{6})*" は6つの "'a'" の0回以上の繰り返しに適合します。

特殊文字を以下に示します:

"."
   (ドット) デフォルトのモードでは改行以外の任意の文字にマッチします。
   "DOTALL" フラグが指定されていれば改行も含むすべての文字にマッチしま
   す。

"^"
   (キャレット) 文字列の先頭とマッチします。 "MULTILINE" モードでは各
   改行の直後にマッチします。

"$"
   文字列の末尾、あるいは文字列の末尾の改行の直前にマッチします。例え
   ば、 "foo" は 'foo' と 'foobar' の両方にマッチします。一方、正規表
   現 "foo$" は 'foo' だけとマッチします。興味深いことに、
   "'foo1\nfoo2\n'" を "foo.$" で検索した場合、通常のモードでは 'foo2'
   だけにマッチし、 "MULTILINE" モードでは 'foo1' にもマッチします。
   "$" だけで "'foo\n'" を検索した場合、2箇所 (内容は空) でマッチしま
   す: 1つは、改行の直前で、もう1つは、文字列の最後です。

"*"
   直前にある RE に作用して、 RE を 0 回以上できるだけ多く繰り返したも
   のにマッチさせるようにします。例えば "ab*" は 'a'、'ab'、あるいは
   'a' に任意個数の'b' を続けたものにマッチします。

"+"
   直前にある RE に作用して、 RE を、1 回以上繰り返したものにマッチさ
   せるようにします。例えば "ab+" は 'a' に一つ以上の 'b' が続いたもの
   にマッチし、 'a' 単体にはマッチしません。

"?"
   直前にある RE に作用して、 RE を 0 回か 1 回繰り返したものにマッチ
   させるようにします。例えば "ab?" は 'a' あるいは 'ab' にマッチしま
   す。

"*?", "+?", "??"
   "'*'" 、 "'+'" 、 "'?'" といった修飾子は、すべて *貪欲 (greedy)* マ
   ッチ、すなわちできるだけ多くのテキストにマッチするようになっていま
   す。時にはこの動作が望ましくない場合もあります。例えば正規表現
   "<.*>" を "'<a> b <c>'" にマッチさせると、 "'<a>'" だけにマッチする
   のではなく全文字列にマッチしてしまいます。 "?" を修飾子の後に追加す
   ると、 *非貪欲 (non-greedy)* あるいは *最小一致 (minimal)* のマッチ
   になり、できるだけ *少ない* 文字数のマッチになります。例えば正規表
   現 "<.*?>" を使うと "'<a>'" だけにマッチします。

"{m}"
   前にある RE の *m* 回の正確なコピーとマッチすべきであることを指定し
   ます；マッチ回数が少なければ、RE 全体ではマッチしません。例えば、
   "a{6}" は、正確に 6個の "'a'" 文字とマッチしますが、 5個ではマッチ
   しません。

"{m,n}"
   結果の RE は、前にある RE を、*m* 回から *n* 回まで繰り返したもので
   、できるだけ多く繰り返したものとマッチするように、マッチします。例
   えば、"a{3,5}" は、3個から 5個の "'a'" 文字とマッチします。*m* を省
   略するとマッチ回数の下限として0を指定した事になり、*n* を省略するこ
   とは、上限が無限であることを指定します;  "a{4,}b" は "'aaaab'" や、
   1,000 個の "'a'" 文字に "'b'" が続いたものとマッチしますが、
   "'aaab'" とはマッチしません。コンマは省略できません、省略すると修飾
   子が上で述べた形式と混同されてしまうからです。

"{m,n}?"
   結果の RE は、前にある RE の *m* 回から *n* 回まで繰り返したもので
   、できるだけ *少なく* 繰り返したものとマッチするように、マッチしま
   す。これは、前の修飾子の控え目バージョンです。例えば、 6文字文字列
   "'aaaaaa'" では、 "a{3,5}" は、5個の "'a'" 文字とマッチしますが、
   "a{3,5}?" は3個の文字とマッチするだけです。

"\"
   特殊文字をエスケープする( "'*'" や "'?'" 等のような文字とのマッチを
   できるようにする) か、あるいは、特殊シーケンスの合図です; 特殊シー
   ケンスは後で議論します。

   もしパターンを表現するのに raw string を使用していないのであれば、
   Python も、バックスラッシュを文字列リテラルでのエスケープシーケンス
   として使っていることを覚えていて下さい。エスケープシーケンスを
   Python の構文解析器が認識して処理しない場合、そのバックスラッシュと
   それに続く文字は、結果の文字列にそのまま含まれます。しかし、Python
   が結果のシーケンスを認識する場合は、バックスラッシュを 2回繰り返さ
   なければいけません。これは複雑で理解しにくいので、最も簡単な表現以
   外は、すべて raw string を使うことを強く推奨します。

"[]"
   文字の集合を指定するのに使用します。集合には以下のものが指定できま
   す:

   * 個別に指定できる文字。 "[amk]" は "'a'", "'m'", "'k'" とマッチし
     ます。

   * 連続した文字の範囲を、先頭と最後の2文字とその間に "'-'" を挟んだ
     形で指定できます。"[a-z]" はすべての小文字の ASCII 文字とマッチし
     ます。"[0-5][0-9]" は "00" から "59" までの、すべての 2 桁の数字
     とマッチします。"[0-9A-Fa-f]" は任意の 16 進数の数字とマッチしま
     す。"-" が、エスケープされた場合 (例: "[a\-z]")、あるいは先頭か末
     尾に置かれた場合 (例: "[-a]" や "[a-]")、リテラル "'-'" とマッチ
     します。

   * 集合内では、特殊文字はその意味を失います。 "[(+*)]" はリテラル文
     字 "'('" "'+'" 、 "'*'" 、あるいは "')'" のいずれかとマッチします
     。

   * "\w" や "\S" のような文字クラス (後述) も集合内に指定できますが、
     それらにマッチする文字は "ASCII" か "LOCALE" のどちらか有効にされ
     ているモードに依存します。

   * 範囲内にない文字とは、その集合の *補集合* をとることでマッチでき
     ます。集合の最初の文字が "'^'" の時、集合に *ない* 文字すべてとマ
     ッチします。 "[^5]" は "'5'" を除くあらゆる文字にマッチします。
     "[^^]" は "'^'" を除くあらゆる文字にマッチします。 "^" は集合の最
     初の文字でない限り特別の意味を持ちません。

   * 集合内でリテラル "']'" をマッチさせるには、その前にバックスラッシ
     ュをつけるか、集合の先頭に置きます。 "[()[\]{}]" と "[]()[{}]" は
     どちらも "']'" にマッチします。

"|"
   "A|B" (*A* と *B* は任意の RE) は、 *A* か *B* のどちらかとマッチす
   る正規表現を作成します。任意個数の RE を、このように "'|'" で分離す
   ることができます。これはグループ (下記参照) 内部でも使えます。走査
   対象文字列をスキャンする中で、"'|'" で分離された RE は左から右への
   順に走査されます。一つでも完全にマッチしたパターンがあれば、そのパ
   ターン枝が受理されます。このことは、もし *A* がマッチすれば、たとえ
   *B* によるマッチが全体としてより長いマッチになったとしても、 *B* を
   決して走査しないことを意味します。言いかえると、"'|'" 演算子は決し
   て貪欲 (greedy) にはなりません。リテラル "'|'" とマッチするには、
   "\|" を使うか、あるいは "[|]" のように文字クラス内に入れます。

"(...)"
   丸括弧の中にどのような正規表現があってもマッチし、丸括弧はグループ
   の開始と終了を表します; グループの中身は、マッチが実行された後に回
   収され、特殊シーケンス "\number" (後述) で参照することができます。
   リテラル "'('" や "')'" とマッチするには、"\(" や "\)" を使うか、そ
   れらを文字クラス内に入れます:  "[(]", "[)]" 。

"(?...)"
   これは拡張記法です ("'('" に続く "'?'" は他には意味がありません) 。
   "'?'" の後の最初の文字が、この構造の意味とこれ以上のシンタックスが
   どういうものであるかを決定します。拡張記法は普通新しいグループを作
   成しません； "(?P<name>...)" がこの規則の唯一の例外です。以下に現在
   サポートされている拡張記法を示します。

"(?aiLmsux)"
   ("'a'", "'i'", "'L'", "'m'", "'s'", "'u'", "'x'" の集合にある文字を
   1 個以上。) グループは空文字列ともマッチします; 正規表現全体に対し
   て、文字に対応するフラグ、 "re.A" (ASCII 限定マッチ)、"re.I" (大文
   字・小文字を区別しない)、"re.L" (ロケール依存)、"re.M" (MULTILINE
   モード)、"re.S" (DOTALL モード)、 "re.U" (Unicode マッチ)、 "re.X"
   (冗長) を設定します。 (フラグについては モジュールコンテンツ を参照
   してください。) これは、*flag* 引数を "re.compile()" 関数に渡すので
   はなく、そのフラグを正規表現の一部に含めたい場合に役立ちます。 フラ
   グは正規表現文字列の先頭で使うべきです。

"(?:...)"
   正規表現の丸括弧の取り込まないバージョンです。どのような正規表現が
   丸括弧内にあってもマッチしますが、グループによってマッチされたサブ
   文字列は、マッチを実行したあと検索されることも、あるいは後でパター
   ンで参照されることも *できません* 。

"(?imsx-imsx:...)"
   ("'i'", "'m'", "'s'", "'x'" の集合にある文字を 0 個以上、それに続く
   オプショナルな "'-'" と先程と同じ集合にある文字を 1 個以上。) 正規
   表現の一部に対して、文字に対応するフラグ、"re.I" (大文字・小文字を
   区別しない), "re.M" (MULTILINE モード), "re.S" (DOTALL モード),
   "re.X" (冗長) を設定したり除去したりします。 (これらのフラグについ
   ては モジュールコンテンツ に解説があります。)

   バージョン 3.6 で追加.

"(?P<name>...)"
   正規表現の丸括弧に似ていますが、グループによってマッチした部分文字
   列はシンボリックグループ名 *name* によってアクセス可能になります。
   グループ名は有効な Python 識別子でなければならず、グループ名は 1 個
   の正規表現内で一意でなければなりません。シンボリックグループは番号
   付けもされており、番号によるアクセスも可能です。

   名前付きグループは 3 つのコンテキストで参照できます。パターンが
   "(?P<quote>['\"]).*?(?P=quote)" (シングルまたはダブルクオートのどち
   らかにマッチ) の場合`:

   +-----------------------------------------+------------------------------------+
   | グループ "quote" を参照するコンテキスト | 参照方法                           |
   |=========================================|====================================|
   | 同一パターンへの参照                    | * "(?P=quote)" (そのまま)  * "\1"  |
   +-----------------------------------------+------------------------------------+
   | マッチオブジェクト *m* の処理時         | * "m.group('quote')"  *            |
   |                                         | "m.end('quote')" (etc.)            |
   +-----------------------------------------+------------------------------------+
   | "re.sub()" の *repl* 引数へ渡される文字 | * "\g<quote>"  * "\g<1>"  * "\1"   |
   | 列                                      |                                    |
   +-----------------------------------------+------------------------------------+

"(?P=name)"
   名前付きグループへの後方参照です; 既出のグループ名 *name* にマッチ
   する文字列は何にでもマッチします。

"(?#...)"
   コメントです；括弧の内容は単純に無視されます。

"(?=...)"
   "..." が次に続くものとマッチすればマッチしますが、文字列をまったく
   消費しません。これは *先読みアサーション (lookahead assertion)* と
   呼ばれます。例えば、"Isaac (?=Asimov)" は、"'Isaac '" に "'Asimov'"
   が続く場合だけ、"'Isaac '" とマッチします。

"(?!...)"
   "..." が次に続くものとマッチしなければマッチします。これは *否定先
   読みアサーション (negative lookahead assertion)* です。例えば、
   "Isaac (?!Asimov)" は、"'Isaac '" に "'Asimov'" が続か *ない* 場合
   のみマッチします。

"(?<=...)"
   文字列内の現在位置の前に、現在位置で終わる "..." とのマッチがあれば
   、マッチします。これは *後読みアサーション* と呼ばれます。
   "(?<=abc)def" は "'abcdef'" にマッチを見つけます。後読みは 3 文字を
   バックアップし、含まれているパターンとマッチするかどうか検査します
   。含まれるパターンは、固定長の文字列にのみマッチしなければなりませ
   ん。すなわち、"abc" や "a|b" は許されますが、"a*" や "a{3,4}" は許
   されません。肯定後読みアサーションで始まるパターンは、検索される文
   字列の先頭とは決してマッチしないことに注意して下さい; この表現を使
   用するのは、おそらく "match()" 関数より "search()" 関数の方が適して
   います:

   >>> import re
   >>> m = re.search('(?<=abc)def', 'abcdef')
   >>> m.group(0)
   'def'

   この例ではハイフンに続く単語を探します:

   >>> m = re.search(r'(?<=-)\w+', 'spam-egg')
   >>> m.group(0)
   'egg'

   バージョン 3.5 で変更: 固定長のグループ参照をサポートするようになり
   ました。

"(?<!...)"
   文字列内の現在位置の前に "..." とのマッチがない場合に、マッチします
   。これは *否定後読みアサーション(negative lookbehind assertion)* と
   呼ばれます。肯定後読みアサーションと同様に、含まれるパターンは固定
   長さの文字列だけにマッチしなければなりません。否定後読みアサーショ
   ンで始まるパターンは、検索される文字列の先頭とマッチできます。

"(?(id/name)yes-pattern|no-pattern)"
   与えられたグループ *id* あるいは *name* が存在する場合、"yes-
   pattern" とのマッチを、存在しない場合 "no-pattern" とのマッチを試み
   ます。"no-pattern" は省略可能です。例えば、
   "(<)?(\w+@\w+(?:\.\w+)+)(?(1)>|$)" は貧弱な E-mail マッチングパター
   ンで、"'<user@host.com>'" や "'user@host.com'" にマッチしますが、
   "'<user@host.com'" や "'user@host.com>'" とはマッチしません。

特殊シーケンスは "'\'" と以下のリストの文字から構成されます。 ASCII の
数値や ASCII の文字でない通常の文字の場合、 RE は 2 番目の文字とマッチ
します。 例えば、"\$" は文字 "'$'" とマッチします。

"\number"
   同じ番号のグループの中身とマッチします。グループは1から始まる番号を
   つけられます。例えば、 "(.+) \1" は、 "'the the'" あるいは "'55
   55'" とマッチしますが、 "'thethe'" とはマッチしません(グループの後
   のスペースに注意して下さい)。この特殊シーケンスは最初の 99 グループ
   のうちの一つとマッチするのに使うことができるだけです。もし *number*
   の最初の桁が 0 である、すなわち *number* が 3 桁の8進数であれば、そ
   れはグループのマッチとは解釈されず、 8進数値 *number* を持つ文字と
   して解釈されます。文字クラスの "'['" と "']'" の中の数値エスケープ
   は、文字として扱われます。

"\A"
   文字列の先頭だけにマッチします。

"\b"
   空文字列とマッチしますが、単語の先頭か末尾の時だけです。 単語とは単
   語文字の並びとして定義されます。 形式的に記述すると、 "\b" は "\w"
   文字および "\W" 文字の間 (およびその逆)、あるいは "\w" と文字列の開
   始/終了との間の境界として定義されています。 例えば、"r'\bfoo\b'" は
   "'foo'" , "'foo.'" , "'(foo)'", "'bar foo baz'" にマッチしますが、
   "'foobar'", "'foo3'" にはマッチしません。

   デフォルトの Unicode 英数字は Unicode パターン中で使われるものと同
   じですが、これは "ASCII" フラグを使って変更できます。 "LOCALE" フラ
   グが使われているなら単語の境界は現在のロケールによって決定されます
   。Python の文字列リテラルとの互換性のため、文字列範囲中では、 "\b"
   は後退 (backspace) 文字を表します。

"\B"
   空文字列にマッチしますが、それが単語の先頭か末尾 *でない* ときのみ
   です。つまり "r'py\B'" は "'python'" 、 "'py3'" 、"'py2'" にマッチ
   しますが、 "'py'" 、 "'py.'" 、 または "'py!'" にはマッチしません。
   "\B" は "\b" のちょうど反対で、 Unicode パターンにおける単語文字は
   Unicode 英数字およびアンダースコアですが、 これは "ASCII" フラグを
   使って変更できます。 "LOCALE" フラグが使われているなら単語の境界は
   現在のロケールによって決定されます。

"\d"
   ユニコード (str) パターンに対して:
      任意の Unicode 10進数 (Unicode 文字カテゴリ [Nd]) とマッチします
      。これには "[0-9]" とその他の 10 進数文字が含まれます。"ASCII"
      が使用された場合、"[0-9]" のみマッチします。ただし、このフラグは
      正規表現全体に作用しますので、明示的に "[0-9]" と指定する方が良
      い場合があるかもしれません。

   8bit (bytes) パターンに対して:
      任意の 10 進数にマッチします; これは "[0-9]" と等価です。

"\D"
   任意の非 10 進数文字にマッチします。これは "\d" の反対です。"ASCII"
   フラグを使用すると "[^0-9]" と等価になります (ただし、このフラグは
   正規表現全体に作用しますので、明示的に "[^0-9]" と指定する方が良い
   でしょう)。

"\s"
   ユニコード (str) パターンに対して:
      任意の空白文字とマッチします。これには "[ \t\n\r\f\v]" およびノ
      ーブレークスペースなど、多くの言語におけるタイポグラフィ規則で定
      義された文字が含まれます。"ASCII" フラグを使用すると、"[
      \t\n\r\f\v]" のみにマッチします。ただし、このフラグは正規表現全
      体に作用しますので、明示的に "[ \t\n\r\f\v]" と指定する方が良い
      場合があるかもしれません。

   8bit (bytes) パターンに対して:
      ASCII 文字セットにおける空白文字とマッチします。これは "[
      \t\n\r\f\v]" と等価です。

"\S"
   任意の非空白文字にマッチします。これは "\s" の反対です。"ASCII" フ
   ラグを使用すると "[^ \t\n\r\f\v]" と等価になります (ただし、このフ
   ラグは正規表現全体に作用しますので、明示的に "[^ \t\n\r\f\v]" と指
   定する方が良いでしょう)。

"\w"
   ユニコード (str) パターンに対して:
      任意の Unicode 単語文字にマッチします。これにはあらゆる言語で単
      語の一部になりうる文字、数字、およびアンダースコアが含まれます。
      "ASCII" フラグを使用すると "[a-zA-Z0-9_]" のみにマッチします。た
      だし、このフラグは正規表現全体に作用しますので、明示的に
      "[a-zA-Z0-9_]" と指定する方が良い場合があるかもしれません。

   8bit (bytes) パターンに対して:
      ASCII 文字セットでの英数字とアンダースコアにマッチします。これは
      "[a-zA-Z0-9_]" と等価です。 "LOCALE" が使われている場合は、現在
      のロケールで英数字と見なせる文字とアンダースコアにマッチします。

"\W"
   任意の非単語文字にマッチします。これは "\w" の反対です。"ASCII" フ
   ラグを使用した場合、"[^a-zA-Z0-9_]" と等価になります (ただし、この
   フラグは正規表現全体に作用しますので、明示的に "[^a-zA-Z0-9_]" と指
   定する方が良い場合があるかもしれません)。 "LOCALE" が使われている場
   合は、現在のロケールで英数字と見なせる文字とアンダースコアにマッチ
   します。

"\Z"
   文字列の末尾とのみマッチします。

Python 文字列リテラルによってサポートされている標準エスケープのほとん
ども、正規表現パーザによって認識されます:

   \a      \b      \f      \n
   \r      \t      \u      \U
   \v      \x      \\

("\b" は単語の境界を表し、文字クラス内でのみ後退 (backspace) 文字を指
すことに注意してください)

"'\u'" および "'\U'" エスケープシーケンスは Unicode パターン内でのみ認
識されます。バイト列ではエラーとなります。

8 進数エスケープは限られた形式で表します。最初の桁が 0 か、あるいは 3
桁の 8 進数ならば、8 進数エスケープとみなされます。それ以外の場合はグ
ループ参照になります。文字列リテラルに関しては、8 進数エスケープはほと
んどの場合 3 桁長になります。

バージョン 3.3 で変更: "'\u'" と "'\U'" エスケープシーケンスが追加され
ました。

バージョン 3.6 で変更: "'\'" と ASCII 文字からなる未知のエスケープはエ
ラーになります。


6.2.2. モジュールコンテンツ
===========================

このモジュールはいくつかの関数、定数、例外を定義します。この関数の一部
はコンパイルした正規表現の完全版メソッドを簡略化したバージョンです。簡
単なアプリケーションを除くほとんどで、コンパイルされた形式が用いられる
のが普通です。

バージョン 3.6 で変更: フラグ定数は、"enum.IntFlag" のサブクラスである
"RegexFlag" のインスタンスになりました、

re.compile(pattern, flags=0)

   正規表現パターンを 正規表現オブジェクト にコンパイルします。このオ
   ブジェクトは、以下で述べる "match()" や "search()" や他のメソッドを
   使って、マッチングに使うことができます。

   式の動作は、 *flags* の値を指定することで加減することができます。値
   は以下の変数を、ビットごとの OR ( "|" 演算子)を使って組み合わせるこ
   とができます。

   シーケンス

      prog = re.compile(pattern)
      result = prog.match(string)

   は、以下と同等です

      result = re.match(pattern, string)

   ただし、その式を一つのプログラムで何回も使う場合には、
   "re.compile()" を使ってその結果の正規表現オブジェクトを再利用した方
   がより効率的です。

   注釈:

     "re.compile()" に渡されてコンパイルされた最新のパターンと、モジュ
     ールレベルのマッチング関数はキャッシュされるので、一度に少しの正
     規表現しか使わないプログラムは正規表現のコンパイルについて心配す
     る必要はありません。

re.A
re.ASCII

   "\w"、"\W"、"\b"、"\B"、"\d"、"\D"、"\s"、および "\S" において、
   ASCII 文字のみでマッチングを行います。これは Unicode パターンでのみ
   意味があり、バイト列パターンでは無視されます。 インラインフラグの
   "(?a)" に相当します。

   後方互換性のため、"re.U" フラグ (およびそれと同義の "re.UNICODE" と
   埋め込みで使用する "(?u)") はまだ存在していますが、文字列のマッチの
   デフォルトが Unicode になった Python 3 では冗長です (そして Unicode
   マッチングではバイト列は扱えません)。

re.DEBUG

   コンパイルした表現に関するデバッグ情報を出力します。 相当するインラ
   インフラグはありません。

re.I
re.IGNORECASE

   大文字・小文字を区別しないマッチングを実行させます。 "[A-Z]" のよう
   な表現は小文字にもマッチします。 "re.ASCII" フラグが使われて非
   ASCII マッチが無効化されていない限り、完全な Unicode マッチング (例
   えば "Ü" が "ü" にマッチする) も有効です。 "re.LOCALE" フラグが共に
   使われていない限り、現在のロケールは変更されません。インラインフラ
   グの "(?i)" に相当します。

   Note that when the Unicode patterns "[a-z]" or "[A-Z]" are used in
   combination with the "IGNORECASE" flag, they will match the 52
   ASCII letters and 4 additional non-ASCII letters: 'İ' (U+0130,
   Latin capital letter I with dot above), 'ı' (U+0131, Latin small
   letter dotless i), 'ſ' (U+017F, Latin small letter long s) and 'K'
   (U+212A, Kelvin sign). If the "ASCII" flag is used, only letters
   'a' to 'z' and 'A' to 'Z' are matched (but the flag affects the
   entire regular expression, so in such cases using an explicit
   "(?-i:[a-zA-Z])" may be a better choice).

re.L
re.LOCALE

   "\w" 、 "\W" 、 "\b" 、 "\B" および大文字・小文字を区別しないマッチ
   ングを、現在のロケールに依存させます。ロケールの仕組みは信頼できず
   、一度に一つの "文化" しか扱えず、 8 ビットロケールでしか働かないの
   で、このフラグを使うことは推奨されません。Python 3 において Unicode
   (str) パターンでは Unicode マッチングはデフォルトですでに有効にされ
   ていて、異なるロケールや言語を扱えます。インラインフラグの "(?L)"
   に相当します。

   バージョン 3.6 で変更: "re.LOCALE" バイト列のパターンにのみ利用でき
   ます。"re.ASCII" とは同時に指定できません。

re.M
re.MULTILINE

   指定されると、パターン文字 "'^'" は、文字列の先頭および各行の先頭 (
   各改行の直後) とマッチします; そしてパターン文字 "'$'" は文字列の末
   尾および各行の末尾 (改行の直前) とマッチします。デフォルトでは、
   "'^'" は、文字列の先頭とだけマッチし、"'$'" は、文字列の末尾および
   文字列の末尾の改行の直前 (もしあれば) とマッチします。インラインフ
   ラグの "(?m)" に相当します。

re.S
re.DOTALL

   特殊文字 "'.'" を、改行を含むどんな文字にもマッチさせます; このフラ
   グがなければ、"'.'" は、改行 *以外の* 任意の文字とマッチします。 イ
   ンラインフラグの "(?s)" に相当します。

re.X
re.VERBOSE

   このフラグは正規表現を、パターンの論理的な節を視覚的に分割し、コメ
   ントを加えることで、見た目よく読みやすく書けるようにします。パター
   ン中の空白は、文字クラス中にあるときと、エスケープされていないバッ
   クスラッシュの後にあるときと、 "*?" 、 "(?:" や "(?P<...>" のような
   トークン中を除いて無視されます。ある行が文字クラス中でもエスケープ
   されていないバックスラッシュの後でもない "#" を含むなら、一番左のそ
   のような "#" から行末までの全ての文字は無視されます。

   つまり、数字にマッチする下記のふたつの正規表現オブジェクトは、機能
   的に等価です。:

      a = re.compile(r"""\d +  # the integral part
                         \.    # the decimal point
                         \d *  # some fractional digits""", re.X)
      b = re.compile(r"\d+\.\d*")

   インラインフラグの "(?x)" に相当します。

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

   *string* を走査し、正規表現 *pattern* がマッチする最初の場所を探し
   て、対応する match オブジェクト を返します。文字列内にパターンにマ
   ッチする場所が無い場合は "None" を返します; これは文字列内のある場
   所で長さが 0 のマッチが見つかった場合とは異なることに注意してくださ
   い。

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

   もし *string* の先頭で 0 個以上の文字が正規表現 *pattern* とマッチ
   すれば、対応する マッチオブジェクト インスタンスを返します。文字列
   がパターンとマッチしなければ、"None" を返します; これは長さゼロのマ
   ッチとは異なることに注意して下さい。

   "MULTILINE" モードであっても、"re.match()" は文字列の先頭のみにマッ
   チし、各行の先頭にはマッチしないことに注意してください。

   *string* 内のどこでもマッチできるようにするには、代わりに
   "search()" を使ってください (search() vs. match() も参照してくださ
   い)。

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

   *string* 全体が正規表現 *pattern* にマッチした場合、対応する match
   オブジェクト を返します。文字列にパターンにマッチする場所が無い場合
   は "None" を返します; これは長さが 0 のマッチとは違うということを注
   意しておきます。

   バージョン 3.4 で追加.

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

   *string* を、*pattern* があるたびに分割します。キャプチャグループの
   丸括弧が *pattern* で使われていれば、パターン内のすべてのグループの
   テキストも結果のリストの一部として返されます。*maxsplit* がゼロでな
   ければ、最大 *maxsplit* 個の分割が発生し、残りはリストの最終要素と
   して返されます。

      >>> re.split(r'\W+', 'Words, words, words.')
      ['Words', 'words', 'words', '']
      >>> re.split(r'(\W+)', 'Words, words, words.')
      ['Words', ', ', 'words', ', ', 'words', '.', '']
      >>> re.split(r'\W+', 'Words, words, words.', 1)
      ['Words', 'words, words.']
      >>> re.split('[a-f]+', '0a3B9', flags=re.IGNORECASE)
      ['0', '3', '9']

   セパレータ中にキャプチャグループがあり、それが文字列の先頭にマッチ
   するなら、結果は空文字列で始まります。同じことが文字列の末尾にも言
   えます。

      >>> re.split(r'(\W+)', '...words, words...')
      ['', '...', 'words', ', ', 'words', '...', '']

   その場合、常に、分割要素が、分割結果のリストの相対的なインデックス
   に現れます。

   注釈:

     現在、"split()" は空のパターンマッチでは文字列を分割しません。例
     えば、次のようになります:

        >>> re.split('x*', 'axbc')
        ['a', 'bc']

     "'x*'" は 'a' の前、 'b' と 'c' との間、 'c' の後の 0 個の 'x' に
     もマッチしますが、現在これらのマッチは無視されます。正しい動作 (
     空のマッチでも文字列を分割し、"['', 'a', 'b', 'c', '']" を返す)
     は、Python の将来のバージョンで実装されます。これは、後方互換生の
     ない変更であるため、移行期間中は "FutureWarning" が送出されます。
     空の文字列のみとマッチするパターンは、現在文字列を全く分割しませ
     ん。これは望ましい動作ではないため、Python 3.5 から "ValueError"
     が送出されます:

        >>> re.split("^$", "foo\n\nbar\n", flags=re.M)
        Traceback (most recent call last):
          File "<stdin>", line 1, in <module>
          ...
        ValueError: split() requires a non-empty pattern match.

   バージョン 3.1 で変更: オプションの flags 引数が追加されました。

   バージョン 3.5 で変更: 空の文字列にマッチするパターンによって分割し
   ようとすると、警告が送出されるようになりました。空の文字列のみとマ
   ッチするパターンは拒否されるようになりました。

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

   *string* 中の *pattern* による全ての重複しないマッチを、文字列のリ
   ストとして返します。 *string* は左から右へ走査され、マッチは見つか
   った順で返されます。パターン中に 1 つ以上のグループがあれば、グルー
   プのリストを返します。パターンに複数のグループがあればタプルのリス
   トになります。空マッチは結果に含まれます。

   注釈:

     Due to the limitation of the current implementation the character
     following an empty match is not included in a next match, so
     "findall(r'^|\w+', 'two words')" returns "['', 'wo', 'words']"
     (note missed "t").  This is changed in Python 3.7.

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

   Return an *iterator* yielding match objects over all non-
   overlapping matches for the RE *pattern* in *string*.  The *string*
   is scanned left-to-right, and matches are returned in the order
   found.  Empty matches are included in the result.  See also the
   note about "findall()".

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

   *string* 中に出現する一番左の重複しない *pattern* を置換 *repl* で
   置換することで得られる文字列を返します。パターンが見つからなければ
   、 *string* がそのまま返されます。 *repl* は文字列または関数です。
   それが文字列なら、その中の全てのバックスラッシュエスケープが処理さ
   れます。 "\n" は 1 つの改行文字に変換され、 "\r" はキャリッジリター
   ンに変換される、などです。 "\&" のような未知のエスケープは残されま
   す。後方参照は、例えば "\6" は、グループ 6 がパターン中でマッチした
   部分文字列で置換されます。例えば:

      >>> re.sub(r'def\s+([a-zA-Z_][a-zA-Z_0-9]*)\s*\(\s*\):',
      ...        r'static PyObject*\npy_\1(void)\n{',
      ...        'def myfunc():')
      'static PyObject*\npy_myfunc(void)\n{'

   もし *repl* が関数であれば、重複しない *pattern* が発生するたびにそ
   の関数が呼ばれます。この関数は一つの マッチオブジェクト 引数を取り
   、置換文字列を返します。例えば:

      >>> def dashrepl(matchobj):
      ...     if matchobj.group(0) == '-': return ' '
      ...     else: return '-'
      >>> re.sub('-{1,2}', dashrepl, 'pro----gram-files')
      'pro--gram files'
      >>> re.sub(r'\sAND\s', ' & ', 'Baked Beans And Spam', flags=re.IGNORECASE)
      'Baked Beans & Spam'

   パターンは、文字列でも パターンオブジェクト でも構いません。

   省略可能な引数 *count* は、置換されるパターンの出現回数の最大値です
   ； *count* は非負の整数でなければなりません。もし省略されるかゼロで
   あれば、出現したものがすべて置換されます。パターンのマッチが空であ
   れば、以前のマッチと隣合わせでない時だけ置換されますので、
   "sub('x*', '-', 'abc')" は "'-a-b-c-'" を返します。

   文字列タイプ *repl* 引数では、上で述べた文字エスケープや後方参照の
   他に、 "\g<name>" は、 "(?P<name>...)" シンタックスで定義された
   "name" グループによるマッチ部分文字列を使用することになりますし、
   "\g<number>" は対応するグループ番号への参照となります; "\g<2>" はつ
   まり "\2" と等価ですが、 "\g<2>0" のような置換においても曖昧になり
   ません。 "\20" は、グループ 20への参照として解釈され、グループ 2 に
   リテラル文字 "'0'" が続いたものへの参照としては解釈されないかもしれ
   ません。後方参照 "\g<0>" は、RE とマッチするサブ文字列全体を置き換
   えます。

   バージョン 3.1 で変更: オプションの flags 引数が追加されました。

   バージョン 3.5 で変更: マッチしないグループは空文字列に置き換えられ
   ます。

   バージョン 3.6 で変更: *pattern* 中に "'\'" と ASCII 文字からなる未
   知のエスケープがあると、エラーになります。

   Deprecated since version 3.5, will be removed in version 3.7:
   Unknown escapes in *repl* consisting of "'\'" and an ASCII letter
   now raise a deprecation warning and will be forbidden in Python
   3.7.

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

   "sub()" と同じ操作を行いますが、タプル "(new_string、
   number_of_subs_made)" を返します。

   バージョン 3.1 で変更: オプションの flags 引数が追加されました。

   バージョン 3.5 で変更: マッチしないグループは空文字列に置き換えられ
   ます。

re.escape(pattern)

   *pattern* に含まれる、ASCII 文字、数字、および "'_'" を除くすべての
   文字をエスケープします。 これは、もしその中に正規表現のメタ文字を持
   つかもしれない任意のリテラル文字列とマッチしたい時に役立ちます。 例
   えば:

      >>> print(re.escape('python.exe'))
      python\.exe

      >>> legal_chars = string.ascii_lowercase + string.digits + "!#$%&'*+-.^_`|~:"
      >>> print('[%s]+' % re.escape(legal_chars))
      [abcdefghijklmnopqrstuvwxyz0123456789\!\#\$\%\&\'\*\+\-\.\^_\`\|\~\:]+

      >>> operators = ['+', '-', '*', '/', '**']
      >>> print('|'.join(map(re.escape, sorted(operators, reverse=True))))
      \/|\-|\+|\*\*|\*

   この関数は、バックスラッシュのみをエスケープするべき "sub()" および
   "subn()" における置換文字列に使われてはなりません。例えば:

      >>> digits_re = r'\d+'
      >>> sample = '/usr/sbin/sendmail - 0 errors, 12 warnings'
      >>> print(re.sub(digits_re, digits_re.replace('\\', r'\\'), sample))
      /usr/sbin/sendmail - \d+ errors, \d+ warnings

   バージョン 3.3 で変更: "'_'" 文字がエスケープされなくなりました。

re.purge()

   正規表現キャッシュをクリアします。

exception re.error(msg, pattern=None, pos=None)

   これらの関数のいずれかに渡された文字列が有効な正規表現ではない (例:
   括弧が対になっていない) 場合、またはコンパイル時やマッチング時にな
   んらかのエラーが発生した場合に発生する例外です。文字列にパターンと
   マッチする部分がなくても、それはエラーではありません。エラーインス
   タンスには、次のような追加の属性があります。

   msg

      フォーマットされていないエラーメッセージです。

   pattern

      正規表現のパターンです。

   pos

      *pattern* のコンパイルに失敗した場所のインデックスです ("None"
      の場合もあります)。

   lineno

      *pos* に対応する行です ("None" の場合もあります)。

   colno

      *pos* に対応する列です ("None" の場合もあります)。

   バージョン 3.5 で変更: 追加の属性が追加されました。


6.2.3. 正規表現オブジェクト
===========================

コンパイル済み正規表現オブジェクトは以下のメソッドと属性をサポートしま
す:

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

   *string* を走査し、正規表現がマッチする最初の場所を探して、対応する
   match オブジェクト を返します。文字列内にパターンにマッチする場所が
   ない場合は "None" を返します; これは文字列内のある場所で長さが 0 の
   マッチが見つかった場合とは異なることに注意してください。

   省略可能な、2つ目の引数 *pos* は、 string のどこから探し始めるかを
   指定する index で、デフォルトでは 0 です。これは、文字列をスライス
   してから検索するのと、完全には同じではありません。パターン文字
   "'^'" は本当の文字列の先頭と、改行の直後にマッチしますが、検索を開
   始する index がマッチするとは限りません。

   オプションの引数 *endpos* は文字列の検索範囲を制限します。 これは文
   字列の長さが *endpos* 文字だった場合と同じとみなし、*pos* から
   "endpos - 1" の範囲の文字に対してマッチを探します。 *endpos* が
   *pos* よりも小さい場合は、マッチは見つかりません; それ以外の場合は
   、*rx* をコンパイルされた正規表現だとして、"rx.search(string, 0,
   50)" は "rx.search(string[:50], 0)" と等価です。:

      >>> pattern = re.compile("d")
      >>> pattern.search("dog")     # Match at index 0
      <_sre.SRE_Match object; span=(0, 1), match='d'>
      >>> pattern.search("dog", 1)  # No match; search doesn't include the "d"

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

   *string* の *先頭の* 0 個以上の文字がこの正規表現とマッチする場合、
   対応する マッチオブジェクト を返します。文字列がパターンとマッチし
   ない場合、"None" を返します。これは長さゼロのマッチとは異なることに
   注意してください。

   オプションの引数 *pos* と *endpos* 引数は、 "search()" メソッドと同
   じ意味を持ちます。:

      >>> pattern = re.compile("o")
      >>> pattern.match("dog")      # No match as "o" is not at the start of "dog".
      >>> pattern.match("dog", 1)   # Match as "o" is the 2nd character of "dog".
      <_sre.SRE_Match object; span=(1, 2), match='o'>

   *string* 内のどこでもマッチできるようにするには、代わりに
   "search()" を使ってください (search() vs. match() も参照してくださ
   い)。

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

   *string* 全体がこの正規表現にマッチした場合、対応する match オブジ
   ェクト を返します。文字列にパターンにマッチする場所が無い場合は
   "None" を返します; これは長さが 0 のマッチとは違うということを注意
   しておきます。

   オプションの引数 *pos* と *endpos* 引数は、 "search()" メソッドと同
   じ意味を持ちます。:

      >>> pattern = re.compile("o[gh]")
      >>> pattern.fullmatch("dog")      # No match as "o" is not at the start of "dog".
      >>> pattern.fullmatch("ogre")     # No match as not the full string matches.
      >>> pattern.fullmatch("doggie", 1, 3)   # Matches within given limits.
      <_sre.SRE_Match object; span=(1, 3), match='og'>

   バージョン 3.4 で追加.

regex.split(string, maxsplit=0)

   "split()" 関数と同様で、コンパイルしたパターンを使います。ただし、
   "match()" と同じように、省略可能な *pos*, *endpos* 引数で検索範囲を
   指定することができます。

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

   "findall()" 関数と同じく、コンパイルしたパターンを使います。 ただし
   、 "search()" と同じように、オプションの引数の *pos* と *endpos* で
   検索範囲を制限できます。

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

   "finditer()" 関数と同じく、コンパイルしたパターンを使います。 ただ
   し、 "search()" と同じように、オプションの引数の *pos* と *endpos*
   で検索範囲を制限できます。

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

   "sub()" 関数と同様で、コンパイルしたパターンを使います。

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

   "subn()" 関数と同様で、コンパイルしたパターンを使います。

regex.flags

   正規表現のマッチングフラグです。これは "compile()" で指定されたフラ
   グ、パターン内の "(?...)" インラインフラグ、およびパターンが
   Unicode 文字列だった時の "UNICODE" のような暗黙のフラグとの組み合わ
   せになりなす。

regex.groups

   パターンにあるキャプチャグループの数です。

regex.groupindex

   "(?P<id>)" で定義された任意の記号グループ名の、グループ番号への辞書
   マッピングです。もし記号グループがパターン内で何も使われていなけれ
   ば、辞書は空です。

regex.pattern

   RE オブジェクトがコンパイルされたときに使用された元のパターン文字列
   です。


6.2.4. match オブジェクト
=========================

マッチオブジェクトは常にブール値 "True" を持ちます。 "match()" と
"search()" はマッチしなかった場合に "None" を返すので、単純な "if" ス
テートメントによってマッチしたかどうかをテストできます:

   match = re.search(pattern, string)
   if match:
       process(match)

マッチオブジェクトは以下のメソッドと属性をサポートしています:

match.expand(template)

   テンプレート文字列 *template* に対し、"sub()" メソッドがするような
   バックスラッシュ置換をして得られる文字列を返します。"\n" のようなエ
   スケープは適切な文字に変換され、数値の後方参照 ("\1", "\2") と名前
   付きの後方参照 ("\g<1>", "\g<name>") は、対応するグループの内容で置
   き換えられます。

   バージョン 3.5 で変更: マッチしないグループは空文字列に置き換えられ
   ます。

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

   このマッチの 1 つ以上のサブグループを返します。引数が 1 つなら結果
   は 1 つの文字列です。複数の引数があれば、結果は引数ごとに 1 項目の
   タプルです。引数がなければ、 *group1* はデフォルトで 0 (マッチ全体
   が返される) です。 *groupN* 引数が 0 なら、対応する返り値はマッチし
   た文字列全体です。1 以上 99 以下なら、丸括弧による対応するグループ
   にマッチする文字列です。グループ番号が負であるかパターン中で定義さ
   れたグループの数より大きければ、 "IndexError" 例外が送出されます。
   あるグループがパターンのマッチしなかった部分に含まれているなら、対
   応する結果は "None" です。あるグループがパターンの複数回マッチした
   部分に含まれているなら、最後のマッチが返されます。

      >>> m = re.match(r"(\w+) (\w+)", "Isaac Newton, physicist")
      >>> m.group(0)       # The entire match
      'Isaac Newton'
      >>> m.group(1)       # The first parenthesized subgroup.
      'Isaac'
      >>> m.group(2)       # The second parenthesized subgroup.
      'Newton'
      >>> m.group(1, 2)    # Multiple arguments give us a tuple.
      ('Isaac', 'Newton')

   もし正規表現が "(?P<name>...)" シンタックスを使うならば、 *groupN*
   引数は、それらのグループ名によってグループを識別する文字列であって
   も構いません。もし文字列引数がパターンのグループ名として使われてい
   ないものであれば、 "IndexError" 例外が発生します。

   やや複雑な例:

      >>> m = re.match(r"(?P<first_name>\w+) (?P<last_name>\w+)", "Malcolm Reynolds")
      >>> m.group('first_name')
      'Malcolm'
      >>> m.group('last_name')
      'Reynolds'

   名前付きグループはインデックスでも参照できます:

      >>> m.group(1)
      'Malcolm'
      >>> m.group(2)
      'Reynolds'

   あるグループが複数回マッチすると、その最後のマッチにのみアクセスで
   きます:

      >>> m = re.match(r"(..)+", "a1b2c3")  # Matches 3 times.
      >>> m.group(1)                        # Returns only the last match.
      'c3'

match.__getitem__(g)

   これは "m.group(g)" と同等です。これでマッチの個別のグループに簡単
   にアクセスできます:

      >>> m = re.match(r"(\w+) (\w+)", "Isaac Newton, physicist")
      >>> m[0]       # The entire match
      'Isaac Newton'
      >>> m[1]       # The first parenthesized subgroup.
      'Isaac'
      >>> m[2]       # The second parenthesized subgroup.
      'Newton'

   バージョン 3.6 で追加.

match.groups(default=None)

   パターンにマッチしたすべてのサブグループを含む、パターン内で指定さ
   れたグループ数分の要素を持つタプルを返します。引数 *default* は、マ
   ッチに加わらなかったグループ用に使われ、デフォルトでは "None" です
   。

   例えば:

      >>> m = re.match(r"(\d+)\.(\d+)", "24.1632")
      >>> m.groups()
      ('24', '1632')

   少数位およびその後の全てをオプションにすると、全てのグループがマッ
   チに関係するとは限りません。そういったグループは *default* 引数が与
   えられない限りデフォルトで "None" になります。

      >>> m = re.match(r"(\d+)\.?(\d+)?", "24")
      >>> m.groups()      # Second group defaults to None.
      ('24', None)
      >>> m.groups('0')   # Now, the second group defaults to '0'.
      ('24', '0')

match.groupdict(default=None)

   このマッチの、全ての *名前付き* サブグループを含む、サブグループ名
   をキーとする辞書を返します。 *default* 引数はマッチに関係しなかった
   グループに使われます。デフォルトは "None" です。例えば:

      >>> m = re.match(r"(?P<first_name>\w+) (?P<last_name>\w+)", "Malcolm Reynolds")
      >>> m.groupdict()
      {'first_name': 'Malcolm', 'last_name': 'Reynolds'}

match.start([group])
match.end([group])

   *group* とマッチした部分文字列の先頭と末尾のインデックスを返します
   。 *group* は、デフォルトでは(マッチした部分文字列全体を意味する）
   ゼロです。 *group* が存在してもマッチに寄与しなかった場合は、 "-1"
   を返します。マッチオブジェクト *m* および、マッチに寄与しなかったグ
   ループ *g* があって、グループ *g* とマッチしたサブ文字列 (
   "m.group(g)" と同じ意味ですが ) は:

      m.string[m.start(g):m.end(g)]

   です。もし *group* が空文字列とマッチすれば、 "m.start(group)" が
   "m.end(group)" と等しくなることに注意して下さい。例えば、 "m =
   re.search('b(c?)', 'cba')" とすると、 "m.start(0)" は 1 で、
   "m.end(0)" は 2 であり、 "m.start(1)" と "m.end(1)" はともに 2 であ
   り、 "m.start(2)" は "IndexError" 例外を発生します。

   メールアドレスから *remove_this* を取り除く例:

      >>> email = "tony@tiremove_thisger.net"
      >>> m = re.search("remove_this", email)
      >>> email[:m.start()] + email[m.end():]
      'tony@tiger.net'

match.span([group])

   マッチ *m* について、大きさ2のタプル "(m.start(group),
   m.end(group))" を返します。もし *group* がマッチに寄与しなければ、
   "(-1, -1)" になります。また *group* はデフォルトでゼロです。

match.pos

   正規表現オブジェクト の "search()" か "match()" に渡された *pos* の
   値です。これは RE エンジンがマッチを探し始める位置の文字列のインデ
   ックスです。

match.endpos

   正規表現オブジェクト の "search()" か "match()" に渡された *endpos*
   の値です。これは RE エンジンがそれ以上は進まない位置の文字列のイン
   デックスです。

match.lastindex

   最後にマッチした取り込みグループの整数インデックスです。もしどのグ
   ループも全くマッチしなければ "None" です。例えば、 "(a)b",
   "((a)(b))" や "((ab))" といった表現が "'ab'" に適用された場合、
   "lastindex == 1" となり、同じ文字列に "(a)(b)" が適用された場合には
   "lastindex == 2" となるでしょう。

match.lastgroup

   最後にマッチした取り込みグループの名前です。もしグループに名前がな
   いか、あるいはどのグループも全くマッチしなければ "None" です。

match.re

   The regular expression object whose "match()" or "search()" method
   produced this match instance.

match.string

   "match()" または "search()" へ渡された文字列です。


6.2.5. 正規表現の例
===================


6.2.5.1. ペアの確認
-------------------

この例では、マッチオブジェクトの表示を少し美しくするために、下記の補助
関数を使用します :

   def displaymatch(match):
       if match is None:
           return None
       return '<Match: %r, groups=%r>' % (match.group(), match.groups())

あなたがポーカープログラムを書いているとします。プレイヤーの持ち札はそ
れぞれの文字が1枚のカードを意味する5文字の文字列によって表現されます。
"a" はエース、 "k" はキング、 "q" はクイーン、 "j" はジャック、 "t" は
10、そして "2" から "9" はそれぞれの数字のカードを表します。

与えられた文字列が有効な手札であるか見るには、以下のようにできます:

   >>> valid = re.compile(r"^[a2-9tjqk]{5}$")
   >>> displaymatch(valid.match("akt5q"))  # Valid.
   "<Match: 'akt5q', groups=()>"
   >>> displaymatch(valid.match("akt5e"))  # Invalid.
   >>> displaymatch(valid.match("akt"))    # Invalid.
   >>> displaymatch(valid.match("727ak"))  # Valid.
   "<Match: '727ak', groups=()>"

最後の手札、 ""727ak"" 、はペア、すなわち同じ値の 2 枚のカードを含みま
す。正規表現でこれにマッチするには、このように後方参照を使えます:

   >>> pair = re.compile(r".*(.).*\1")
   >>> displaymatch(pair.match("717ak"))     # Pair of 7s.
   "<Match: '717', groups=('7',)>"
   >>> displaymatch(pair.match("718ak"))     # No pairs.
   >>> displaymatch(pair.match("354aa"))     # Pair of aces.
   "<Match: '354aa', groups=('a',)>"

どのカードのペアになっているかを調べるには、以下のようにマッチオブジェ
クトの "group()" メソッドを使います:

   >>> pair.match("717ak").group(1)
   '7'

   # Error because re.match() returns None, which doesn't have a group() method:
   >>> pair.match("718ak").group(1)
   Traceback (most recent call last):
     File "<pyshell#23>", line 1, in <module>
       re.match(r".*(.).*\1", "718ak").group(1)
   AttributeError: 'NoneType' object has no attribute 'group'

   >>> pair.match("354aa").group(1)
   'a'


6.2.5.2. scanf() をシミュレートする
-----------------------------------

Python には現在のところ、 "scanf()" に相当するものがありません。正規表
現は、 "scanf()" のフォーマット文字列よりも、一般的により強力であり、
また冗長でもあります。以下の表に、 "scanf()" のフォーマットトークンと
正規表現の大体同等な対応付けを示します。

+----------------------------------+-----------------------------------------------+
| "scanf()" トークン               | 正規表現                                      |
|==================================|===============================================|
| "%c"                             | "."                                           |
+----------------------------------+-----------------------------------------------+
| "%5c"                            | ".{5}"                                        |
+----------------------------------+-----------------------------------------------+
| "%d"                             | "[-+]?\d+"                                    |
+----------------------------------+-----------------------------------------------+
| "%e", "%E", "%f", "%g"           | "[-+]?(\d+(\.\d*)?|\.\d+)([eE][-+]?\d+)?"     |
+----------------------------------+-----------------------------------------------+
| "%i"                             | "[-+]?(0[xX][\dA-Fa-f]+|0[0-7]*|\d+)"         |
+----------------------------------+-----------------------------------------------+
| "%o"                             | "[-+]?[0-7]+"                                 |
+----------------------------------+-----------------------------------------------+
| "%s"                             | "\S+"                                         |
+----------------------------------+-----------------------------------------------+
| "%u"                             | "\d+"                                         |
+----------------------------------+-----------------------------------------------+
| "%x", "%X"                       | "[-+]?(0[xX])?[\dA-Fa-f]+"                    |
+----------------------------------+-----------------------------------------------+

以下のような文字列からファイル名と数値を抽出することを考えます

   /usr/sbin/sendmail - 0 errors, 4 warnings

"scanf()" フォーマットは次のように使います

   %s - %d errors, %d warnings

同等な正規表現はこのようなものとなります

   (\S+) - (\d+) errors, (\d+) warnings


6.2.5.3. search() vs. match()
-----------------------------

Python は正規表現ベースの 2 個の基本的な関数、文字列の先頭でのみのマッ
チを確認する "re.match()" および、文字列内の位置にかかわらずマッチを確
認する "re.search()" (Perl でのデフォルトの挙動) を提供しています。

例えば:

   >>> re.match("c", "abcdef")    # No match
   >>> re.search("c", "abcdef")   # Match
   <_sre.SRE_Match object; span=(2, 3), match='c'>

"'^'" で始まる正規表現は、 "search()" において、マッチを文字列の先頭か
らに制限するために使用します:

   >>> re.match("c", "abcdef")    # No match
   >>> re.search("^c", "abcdef")  # No match
   >>> re.search("^a", "abcdef")  # Match
   <_sre.SRE_Match object; span=(0, 1), match='a'>

ただし、 "MULTILINE" モードにおいて "match()" は文字列の先頭でのみマッ
チし、 "'^'" で始まる正規表現で "search()" を使うと各行の先頭でマッチ
することに注意してください。

   >>> re.match('X', 'A\nB\nX', re.MULTILINE)  # No match
   >>> re.search('^X', 'A\nB\nX', re.MULTILINE)  # Match
   <_sre.SRE_Match object; span=(4, 5), match='X'>


6.2.5.4. 電話帳の作成
---------------------

"split()" は文字列を与えられたパターンで分割し、リストにして返します。
下記の、電話帳作成の例のように、このメソッドはテキストデータを読みやす
くしたり、 Python で編集したりしやすくする際に、非常に役に立ちます。

まず、ここに入力があります。普通はファイルから持ってくることもあります
が、ここでは三重クオート文字列構文を使います:

   >>> text = """Ross McFluff: 834.345.1254 155 Elm Street
   ...
   ... Ronald Heathmore: 892.345.3428 436 Finley Avenue
   ... Frank Burger: 925.541.7625 662 South Dogwood Way
   ...
   ...
   ... Heather Albrecht: 548.326.4584 919 Park Place"""

個々の記録は、1つ以上の改行で区切られています。まずは、文字列から空行
を除き、記録ごとのリストに変換しましょう。

   >>> entries = re.split("\n+", text)
   >>> entries
   ['Ross McFluff: 834.345.1254 155 Elm Street',
   'Ronald Heathmore: 892.345.3428 436 Finley Avenue',
   'Frank Burger: 925.541.7625 662 South Dogwood Way',
   'Heather Albrecht: 548.326.4584 919 Park Place']

そして、各記録を、名、姓、電話番号、そして、住所に分割してリストにしま
す。分割のためのパターンに使っている空白文字が、住所には含まれるため、
"split()" の "maxsplit" 引数を使います。 :

   >>> [re.split(":? ", entry, 3) for entry in entries]
   [['Ross', 'McFluff', '834.345.1254', '155 Elm Street'],
   ['Ronald', 'Heathmore', '892.345.3428', '436 Finley Avenue'],
   ['Frank', 'Burger', '925.541.7625', '662 South Dogwood Way'],
   ['Heather', 'Albrecht', '548.326.4584', '919 Park Place']]

パターン、 ":?" は姓に続くコロンにマッチします。そのため、コロンは分割
結果のリストには現れません。 "maxsplit" を "4" にすれば、ハウスナンバ
ーと、ストリート名を分割することができます。 :

   >>> [re.split(":? ", entry, 4) for entry in entries]
   [['Ross', 'McFluff', '834.345.1254', '155', 'Elm Street'],
   ['Ronald', 'Heathmore', '892.345.3428', '436', 'Finley Avenue'],
   ['Frank', 'Burger', '925.541.7625', '662', 'South Dogwood Way'],
   ['Heather', 'Albrecht', '548.326.4584', '919', 'Park Place']]


6.2.5.5. テキストの秘匿
-----------------------

"sub()" はパターンにマッチした部分を文字列や関数の返り値で置き換えます
。この例では、「秘匿」する文字列に、関数と共に "sub()" を適用する例を
示します。言い換えると、最初と最後の文字を除く、単語中の文字の位置をラ
ンダム化します。

   >>> def repl(m):
   ...     inner_word = list(m.group(2))
   ...     random.shuffle(inner_word)
   ...     return m.group(1) + "".join(inner_word) + m.group(3)
   >>> text = "Professor Abdolmalek, please report your absences promptly."
   >>> re.sub(r"(\w)(\w+)(\w)", repl, text)
   'Poefsrosr Aealmlobdk, pslaee reorpt your abnseces plmrptoy.'
   >>> re.sub(r"(\w)(\w+)(\w)", repl, text)
   'Pofsroser Aodlambelk, plasee reoprt yuor asnebces potlmrpy.'


6.2.5.6. 全ての副詞を見つける
-----------------------------

"search()" は最初のパターンにのみマッチしますが、 "findall()" は出現す
る *全ての* パターンにマッチします。例えば、ライターがあるテキストの全
ての副詞を見つけたいなら、以下のように "findall()" を使えます:

   >>> text = "He was carefully disguised but captured quickly by police."
   >>> re.findall(r"\w+ly", text)
   ['carefully', 'quickly']


6.2.5.7. 全ての副詞と、その位置を見つける
-----------------------------------------

パターンの全てのマッチについて、マッチしたテキスト以上の情報が必要なら
、文字列ではなく マッチオブジェクト を返す "finditer()" が便利です。先
の例に続いて、ライターがあるテキストの全ての副詞 *およびその位置* を見
つけたいなら、以下のように "finditer()" を使えます:

   >>> text = "He was carefully disguised but captured quickly by police."
   >>> for m in re.finditer(r"\w+ly", text):
   ...     print('%02d-%02d: %s' % (m.start(), m.end(), m.group(0)))
   07-16: carefully
   40-47: quickly


6.2.5.8. Raw String記法
-----------------------

Raw 文字列記法 ("r"text"") により、バックスラッシュ ("'\'") を個々にバ
ックスラッシュでエスケープすることなしに、正規表現を正常な状態に保つこ
とができます。例えば、以下の 2 つのコードは機能的に等価です:

   >>> re.match(r"\W(.)\1\W", " ff ")
   <_sre.SRE_Match object; span=(0, 4), match=' ff '>
   >>> re.match("\\W(.)\\1\\W", " ff ")
   <_sre.SRE_Match object; span=(0, 4), match=' ff '>

文字通りのバックスラッシュにマッチさせたいなら、正規表現中ではエスケー
プする必要があります。Raw 文字列記法では、"r"\\""  になります。Raw 文
字列記法を用いない場合、""\\\\"" としなくてはなりません。以下のコード
は機能的に等価です:

   >>> re.match(r"\\", r"\\")
   <_sre.SRE_Match object; span=(0, 1), match='\\'>
   >>> re.match("\\\\", r"\\")
   <_sre.SRE_Match object; span=(0, 1), match='\\'>


6.2.5.9. トークナイザを書く
---------------------------

トークナイザやスキャナ は文字列を解析し、文字のグループにカテゴリ分け
します。これはコンパイラやインタプリタを作成する最初の一歩として役立ち
ます。

テキストのカテゴリは正規表現で指定されます。技術的には、それらを一つの
マスター正規表現に結合し、連続したマッチをループさせます:

   import collections
   import re

   Token = collections.namedtuple('Token', ['type', 'value', 'line', 'column'])

   def tokenize(code):
       keywords = {'IF', 'THEN', 'ENDIF', 'FOR', 'NEXT', 'GOSUB', 'RETURN'}
       token_specification = [
           ('NUMBER',   r'\d+(\.\d*)?'),  # Integer or decimal number
           ('ASSIGN',   r':='),           # Assignment operator
           ('END',      r';'),            # Statement terminator
           ('ID',       r'[A-Za-z]+'),    # Identifiers
           ('OP',       r'[+\-*/]'),      # Arithmetic operators
           ('NEWLINE',  r'\n'),           # Line endings
           ('SKIP',     r'[ \t]+'),       # Skip over spaces and tabs
           ('MISMATCH', r'.'),            # Any other character
       ]
       tok_regex = '|'.join('(?P<%s>%s)' % pair for pair in token_specification)
       line_num = 1
       line_start = 0
       for mo in re.finditer(tok_regex, code):
           kind = mo.lastgroup
           value = mo.group()
           column = mo.start() - line_start
           if kind == 'NUMBER':
               value = float(value) if '.' in value else int(value)
           elif kind == 'ID' and value in keywords:
               kind = value
           elif kind == 'NEWLINE':
               line_start = mo.end()
               line_num += 1
               continue
           elif kind == 'SKIP':
               continue
           elif kind == 'MISMATCH':
               raise RuntimeError(f'{value!r} unexpected on line {line_num}')
           yield Token(kind, value, line_num, column)

   statements = '''
       IF quantity THEN
           total := total + price * quantity;
           tax := price * 0.05;
       ENDIF;
   '''

   for token in tokenize(statements):
       print(token)

トークナイザは以下の出力を作成します:

   Token(type='IF', value='IF', line=2, column=4)
   Token(type='ID', value='quantity', line=2, column=7)
   Token(type='THEN', value='THEN', line=2, column=16)
   Token(type='ID', value='total', line=3, column=8)
   Token(type='ASSIGN', value=':=', line=3, column=14)
   Token(type='ID', value='total', line=3, column=17)
   Token(type='OP', value='+', line=3, column=23)
   Token(type='ID', value='price', line=3, column=25)
   Token(type='OP', value='*', line=3, column=31)
   Token(type='ID', value='quantity', line=3, column=33)
   Token(type='END', value=';', line=3, column=41)
   Token(type='ID', value='tax', line=4, column=8)
   Token(type='ASSIGN', value=':=', line=4, column=12)
   Token(type='ID', value='price', line=4, column=15)
   Token(type='OP', value='*', line=4, column=21)
   Token(type='NUMBER', value=0.05, line=4, column=23)
   Token(type='END', value=';', line=4, column=27)
   Token(type='ENDIF', value='ENDIF', line=5, column=4)
   Token(type='END', value=';', line=5, column=9)

[Frie09] Friedl, Jeffrey. Mastering Regular Expressions. 3rd ed.,
         O'Reilly Media, 2009. 当書の第三版ではもはや Python について
         まったく取り扱っていませんが、初版では良い正規表現を書くこと
         を綿密に取り扱っていました。
