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

このモジュールでは、 Perl で見られるものと同様な正規表現マッチング操作
を提供しています。パターンと検索対象文字列の両方について、 8 ビット文
字列と Unicode 文字列を同じように扱えます。

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

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

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

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


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

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

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

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

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

"'|'" や "'('" といったいくつかの文字は特殊文字です。特殊文字は通常の
文字の種別を表したり、あるいは特殊文字の周辺にある通常の文字に対する解
釈方法に影響します。正規表現パターン文字列には、 null byte を含めるこ
とができませんが、 "\number" 記法や、 "'\x00'" などとして指定すること
ができます。

繰り返しの修飾子 ("*", "+", "?", "{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"
   や、千個の "'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-]")、リテラル "'-'" とマッチ
     します 。

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

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

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

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

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

"(...)"
   丸括弧の中にどのような正規表現があってもマッチし、またグループの先
   頭と末尾を表します；グループの中身は、マッチが実行された後に検索さ
   れ、後述する "\number" 特殊シーケンス付きの文字列内で、後でマッチさ
   れます。文字通りの "'('" や "')'" とマッチするには、 "\(" あるいは
   "\)" を使うか、それらを文字クラス内に入れます： "[(] [)]" 。

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

"(?iLmsux)"
   ( 集合 "'i'", "'L'", "'m'", "'s'", "'u'", "'x'" から1文字以上) 。グ
   ループは空文字列ともマッチします；文字は、正規表現全体の対応するフ
   ラグ ("re.I" (大文字・小文字を区別しない), "re.L" (ロケール依存),
   "re.M" (MULTILINEモード), "re.S" (DOTALLモード), "re.U" (Unicode依
   存), "re.X" (冗長) ) を設定します。 (フラグについては、 モジュール
   コンテンツ に記述があります) これは、もし *flag* 引数を
   "re.compile()" 関数に渡さずに、そのフラグを正規表現の一部として含め
   たいならば役に立ちます。

   "(?x)" フラグは、式が構文解析される方法を変更することに注意して下さ
   い。これは式文字列内の最初か、あるいは1つ以上の空白文字の後で使うべ
   きです。もしこのフラグの前に非空白文字があると、その結果は未定義で
   す。

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

"(?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('(?<=-)\w+', 'spam-egg')
   >>> m.group(0)
   'egg'

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

"(?(id/name)yes-pattern|no-pattern)"
   グループに *id* が与えられている、もしくは *name* があるとき、
   "yes-pattern" とマッチします。存在しないときには "no-pattern" とマ
   ッチします。 "no-pattern" はオプションで省略できます。例えば
   "(<)?(\w+@\w+(?:\.\w+)+)(?(1)>)" はemailアドレスとマッチする最低限
   のパターンです。これは "'<user@host.com>'" や "'user@host.com'" に
   はマッチしますが、 "'<user@host.com'" にはマッチしません。

   バージョン 2.4 で追加.

特殊シーケンスは "'\'" と以下のリストにある文字から構成されます。もし
リストにあるのが通常文字でないならば、結果の RE は2番目の文字とマッチ
します。例えば、 "\$" は文字 "'$'" とマッチします。

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

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

"\b"
   空文字列とマッチしますが、単語の先頭か末尾の時だけです。単語とは英
   数字またはアンダースコアからなるシーケンスで、単語の終わりは空白文
   字、あるいはアンダースコアを除く記号で表します。 "\b" は "\w" およ
   び "\W" の間 (およびその逆) あるいは "\w" と文字列の開始/終了との間
   の境界として定義されていますので、文字の正確な集合は "UNICODE" と
   "LOCALE" フラグの値に依存します。例えば、 "r'\bfoo\b'" は "'foo'" ,
   "'foo.'" , "'(foo)'", "'bar foo baz'" にマッチしますが、
   "'foobar'", "'foo3'" にはマッチしません。文字範囲内では、 "\b" は
   Python の文字列リテラルとの互換性のため、後退 (backspace) 文字を表
   します。

"\B"
   空文字列とマッチしますが、それが単語の先頭あるいは末尾に *ない* 時
   だけです。 "r'py\B'" は "'python'", "'py3'", "'py2'" にはマッチしま
   すが、 "'py'", "'py.'", "'py!'" にはマッチしません。これは "\b" の
   ちょうど反対ですので、同じように "LOCALE" と "UNICODE" の設定に影響
   されます。

"\d"
   "UNICODE" フラグが指定されていない場合、任意の十進数とマッチします
   ；これは集合 "[0-9]" と同じ意味です。 "UNICODE" がある場合、Unicode
   文字特性データベースで十進数字と分類されているものにマッチします。

"\D"
   "UNICODE" フラグが指定されていない場合、任意の非数字文字とマッチし
   ます；これは集合 "[^0-9]" と同じ意味です。 "UNICODE" がある場合、こ
   れは Unicode 文字特性データベースで数字とマーク付けされている文字以
   外にマッチします。

"\s"
   "UNICODE" フラグが指定されていない場合、任意の空白文字とマッチし、
   これは集合 "[ \t\n\r\f\v]" と同じ意味です。 "LOCALE" フラグは空白文
   字とのマッチについて特別な意味を持ちません。 "UNICODE" が指定されて
   いる場合、これは "[ \t\n\r\f\v]" と Unicode 文字特性データベースで
   空白と分類されている全てにマッチします。

"\S"
   "UNICODE" フラグが指定されていない場合、任意の非空白文字とマッチし
   、これは集合 "[^ \t\n\r\f\v]" と同じ意味です。 "LOCALE" フラグは非
   空白文字とのマッチについて特別な意味を持ちません。 "UNICODE" が指定
   されている場合、これは Unicode 文字特性データベースで非空白と分類さ
   れている全てにマッチします。

"\w"
   "LOCALE" と "UNICODE" フラグが指定されていない時は、任意の英数文字
   および下線とマッチします；これは、集合 "[a-zA-Z0-9_]" と同じ意味で
   す。 "LOCALE" が設定されていると、集合 "[0-9_]" プラス現在のロケー
   ル用に英数字として定義されている任意の文字とマッチします。もし
   "UNICODE" が設定されていれば、文字 "[0-9_]" プラス Unicode 文字特性
   データベースで英数字として分類されているものとマッチします。

"\W"
   "LOCALE" と "UNICODE" フラグが指定されていない時、任意の非英数文字
   とマッチします；これは集合 "[^a-zA-Z0-9_]" と同じ意味です。
   "LOCALE" が指定されていると、集合 "[0-9_]" になく、現在のロケールで
   英数字として定義されていない任意の文字とマッチします。もし
   "UNICODE" がセットされていれば、これは "[0-9_]" 以外と、および
   Unicode 文字特性データベースで非英数字と分類されている文字とマッチ
   します。

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

特定のシーケンスに対し "LOCALE" と "UNICODE" のどちらも影響しうる場合
は、 "LOCALE" が指定されていれば必ず "LOCALE" の効果に従います。

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

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

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

8進エスケープは制限された形式で含まれています：もし第1桁が 0 であるか
、もし8進3桁であれば、それは 8進エスケープとみなされます。そうでなけれ
ば、それはグループ参照です。文字列リテラルについて、 8進エスケープはほ
とんどの場合3桁長になります。

参考:

  Mastering Regular Expressions 詳説正規表現
     Jeffrey Friedl 著、O'Reilly 刊の正規表現に関する本です。この本の
     第2版ではPyhonについては触れていませんが、良い正規表現パターンの
     書き方を非常にくわしく説明しています。


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

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

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.match()", "re.search()", "re.compile()" に渡され
     たパタ ーンのコンパイルされたものがキャッシュとして残ります。その
     ため、 正規表現をひとつだけしか使わないプログラムは正規表現のコン
     パイル を気にする必要はありません。

re.DEBUG

   コンパイルした表現に関するデバッグ情報を出力します。

re.I
re.IGNORECASE

   Perform case-insensitive matching; expressions like "[A-Z]" will
   match lowercase letters, too.  This is not affected by the current
   locale.  To get this effect on non-ASCII Unicode characters such as
   "ü" and "Ü", add the "UNICODE" flag.

re.L
re.LOCALE

   "\w" 、 "\W" 、 "\b" および、 "\B" 、 "\s" と "\S" を、現在のロケー
   ルに従わさせます。

re.M
re.MULTILINE

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

re.S
re.DOTALL

   特殊文字 "'.'" を、改行を含む任意の文字と、とにかくマッチさせます；
   このフラグがなければ、 "'.'" は、改行 *以外の* 任意の文字とマッチし
   ます。

re.U
re.UNICODE

   Make the "\w", "\W", "\b", "\B", "\d", "\D", "\s" and "\S"
   sequences dependent on the Unicode character properties database.
   Also enables non-ASCII matching for "IGNORECASE".

   バージョン 2.0 で追加.

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*")

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

   *string* 全体を走査して、正規表現 *pattern* がマッチを発生する最初
   の位置を探して、対応する "MatchObject" インスタンスを返します。もし
   文字列内に、そのパターンとマッチする位置がないならば、 "None" を返
   します；これは、文字列内のある点で長さゼロのマッチを探すこととは異
   なることに注意して下さい。

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

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

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

   *string* のどこにでもマッチさせたければ、 "search()" を使って下さい
   (search() vs. match() も参照してください)。

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

   *string* を、 *pattern* があるたびに分割します。もし括弧のキャプチ
   ャが *pattern* で使われていれば、パターン内のすべてのグループのテキ
   ストも結果のリストの一部として返されます。 *maxsplit* がゼロでなけ
   れば、高々 *maxsplit* 個の分割が発生し、文字列の残りは、リストの最
   終要素として返されます。 (非互換性ノート：オリジナルの Python 1.5
   リリースでは、 *maxsplit* は無視されていました。これはその後のリリ
   ースでは修正されました。)

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

   もし、捕捉するグループが分割パターンに含まれ、それが文字列の先頭に
   あるならば、分割結果は、空文字列から始まります。文字列最後において
   も同様です。

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

   その場合、常に、分割要素が、分割結果のリストの相対的なインデックス
   に現れます。 (例えば、分割子の中に捕捉するグループが一つだけあれば
   、0番目、2番目、そして、4番目です)

   *split* は空のパターンマッチでは、文字列を分割しないことに注意して
   下さい。例えば:

   >>> re.split('x*', 'foo')
   ['foo']
   >>> re.split("(?m)^$", "foo\n\nbar\n")
   ['foo\n\nbar\n']

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

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.

   バージョン 1.5.2 で追加.

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

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

   Return an *iterator* yielding "MatchObject" instances 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()".

   バージョン 2.2 で追加.

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

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

   *string* 内で、 *pattern* と重複しないマッチの内、一番左にあるもの
   を置換 *repl* で置換して得られた文字列を返します。もしパターンが見
   つからなければ、 *string* を変更せずに返します。 *repl* は文字列で
   も関数でも構いません；もしそれが文字列であれば、それにある任意のバ
   ックスラッシュエスケープは処理されます。すなわち、 "\n" は単一の改
   行文字に変換され、 "\r" は、キャリッジリターンに変換されます、等々
   。 "\j" のような未知のエスケープはそのままにされます。 "\6" のよう
   な後方参照(backreference)は、パターンのグループ 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'

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

   省略可能な引数 *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 とマッチするサブ文字列全体を置き換
   えます。

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

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

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

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

re.escape(pattern)

   Escape all the characters in *pattern* except ASCII letters and
   numbers. This is useful if you want to match an arbitrary literal
   string that may have regular expression metacharacters in it.  For
   example:

      >>> 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)))
      \/|\-|\+|\*\*|\*

re.purge()

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

exception re.error

   ここでの関数の一つに渡された文字列が、正しい正規表現ではない時 (例
   えば、その括弧が対になっていなかった)、あるいはコンパイルやマッチン
   グの間になんらかのエラーが発生したとき、発生する例外です。たとえ文
   字列がパターンとマッチしなくても、決してエラーではありません。


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

class re.RegexObject

   "RegexObject" クラスは以下のメソッドと属性をサポートします:

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

      *string* を走査して、この正規表現がマッチする場所を探し、対応す
      る "MatchObject" インスタンスを返します。 string のどこにもマッ
      チしない場合は "None" を返します。これは、 string 内のどこかで長
      さ0でマッチした場合と異なることに注意してください。

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

      省略可能な引数 *endpos* は string のどこまでを検索するかを制限し
      ます。これは string の長さが *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 at ...>
      >>> pattern.search("dog", 1)  # No match; search doesn't include the "d"

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

      もし *string* の **先頭の** 0 個以上の文字がこの正規表現とマッチ
      すれば、対応する "MatchObject" インスタンスを返します。もし文字
      列がパターンとマッチしなければ、 "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 at ...>

      *string* のどこにでもマッチさせたければ、代わりに "search()" を
      使って下さい( search() vs. match()) も参照してください)。

   split(string, maxsplit=0)

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

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

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

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

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

   sub(repl, string, count=0)

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

   subn(repl, string, count=0)

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

   flags

      正規表現のマッチングフラグです。これは "compile()" で指定された
      フラグ、およびパターン内の "(?...)" インラインフラグとの組み合わ
      せになりなす。

   groups

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

   groupindex

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

   pattern

      RE オブジェクトがそれからコンパイルされたパターン文字列です。


7.2.4. MatchObject オブジェクト
===============================

class re.MatchObject

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

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

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

   expand(template)

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

   group([group1, ...])

      マッチした1個以上のサブグループを返します。もし引数で一つであれ
      ば、その結果は一つの文字列です。複数の引数があれば、その結果は、
      引数ごとに一項目を持つタプルです。引数がなければ、 *group1* はデ
      フォールトでゼロです(マッチしたものすべてが返されます)。もし
      *groupN* 引数がゼロであれば、対応する戻り値は、マッチする文字列
      全体です。もしそれが範囲 [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'

   groups([default])

      マッチの、1からパターン内にある全グループ数までのすべてのサブグ
      ループを含むタプルを返します。 *default* 引数は、マッチに加わら
      なかったグループ用に使われ、デフォールトでは "None" です。 (非互
      換性ノート：オリジナルの Python 1.5 リリースでは、たとえタプルが
      一要素長であっても、その代わりに文字列を返していました。 (1.5.1
      以降の)後のバージョンでは、そのような場合には、要素がひとつのタ
      プルが返されます。)

      例えば:

      >>> 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')

   groupdict([default])

      マッチの、すべての *名前つきの* サブグループを含む、サブグループ
      名でキー付けされた辞書を返します。 *default* 引数はマッチに加わ
      らなかったグループに使われ、デフォールトでは "None" です。例えば
      、

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

   start([group])
   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'

   span([group])

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

   pos

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

   endpos

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

   lastindex

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

   lastgroup

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

   re

      この "MatchObject" インスタンスを "match()" あるいは "search()"
      メソッドで生成した正規表現オブジェクトです。

   string

      "match()" あるいは "search()" に渡された文字列です。


7.2.5. 例
=========


7.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',)>"

どのカードのペアになっているかを調べるため、下記のように "MatchObject"
の "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'


7.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


7.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 at ...>

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

   >>> re.match("c", "abcdef")    # No match
   >>> re.search("^c", "abcdef")  # No match
   >>> re.search("^a", "abcdef")  # Match
   <_sre.SRE_Match object at ...>

ただし、 "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 at ...>


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

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

最初に、入力を示します。通常、これはファイルからの入力になるでしょう。
ここでは、3重引用符の書式とします :

>>> 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']]


7.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.'


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

"findall()" matches *all* occurrences of a pattern, not just the first
one as "search()" does.  For example, if a writer wanted to find all
of the adverbs in some text, they might use "findall()" in the
following manner:

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


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

If one wants more information about all matches of a pattern than the
matched text, "finditer()" is useful as it provides instances of
"MatchObject" instead of strings.  Continuing with the previous
example, if a writer wanted to find all of the adverbs *and their
positions* in some text, they would use "finditer()" in the following
manner:

>>> 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


7.2.5.8. Raw String記法
-----------------------

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

>>> re.match(r"\W(.)\1\W", " ff ")
<_sre.SRE_Match object at ...>
>>> re.match("\\W(.)\\1\\W", " ff ")
<_sre.SRE_Match object at ...>

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

>>> re.match(r"\\", r"\\")
<_sre.SRE_Match object at ...>
>>> re.match("\\\\", r"\\")
<_sre.SRE_Match object at ...>
