\section{\module{re} --- 正規表現操作}
\declaremodule{standard}{re}
\moduleauthor{Fredrik Lundh}{fredrik@pythonware.com}
\sectionauthor{Andrew M. Kuchling}{amk@amk.ca}


\modulesynopsis{Perl 風のシンタクスを用いた正規表現検索とマッチ操作。}

このモジュールでは、Perl で見られるものと同様な正規表現マッチング操作
を提供しています。正規表現のパターン文字列にはヌルバイトを含められませ
んが、\code{\e\var{number}} 記法を使えばヌルバイトを指定できます。
パターンと検索対象文字列の両方について、 8 ビット文字列と Unicode 文字
列を同じように扱えます。\module{re} モジュールはいつでも利用できます。

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

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

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


\subsection{正規表現のシンタクス \label{re-syntax}}

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

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

以下で正規表現の形式に関する簡単な説明をしておきます。より詳細な情報や
よりやさしい説明に関しては、\url{http://www.python.org/doc/howto/}
からアクセスできる正規表現ハウツウを調べて下さい。

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

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

特殊文字を以下に示します:
%
\begin{description}

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

\item[\character{\textasciicircum}] (キャレット) 
文字列の先頭とマッチします。\constant{MULTILINE} モードでは各改行の直
後にマッチします。

\item[\character{\$}] 
文字列の末尾、あるいは文字列の末尾の改行の直前にマッチします。例えば、
\regexp{foo} は 'foo' と 'foobar' の両方にマッチします。一方、正規表現
\regexp{foo\$}は 'foo' だけとマッチします。興味深いことに、
'foo1\textbackslash nfoo2\textbackslash n' を \regexp{foo.\$} で検索し
た場合、通常のモードでは 'foo2' だけにマッチし、\constant{MULTILINE}
モードでは 'foo1' にもマッチします。

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

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

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

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

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

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

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

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

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

\item[\code{[]}] 文字の集合を指定するのに使用します。文字は個々に
リストするか、文字の範囲を、2つの文字と\character{-}でそれらを分離
して指定することができます。特殊文字は集合内では有効ではありません。
例えば、\regexp{[akm\$]}は、文字 \character{a}、\character{k}、
\character{m}、あるいは \character{\$}のどれかとマッチします；
 \regexp{[a-z]} は、任意の小文字と、\code{[a-zA-Z0-9]} は、
 任意の文字や数字とマッチします。
 (以下で定義する) \code{\e w} や\code{\e S}のような
 文字クラスも、範囲に含めることができます。もし文字集合に
\character{]} や \character{-} を含めたいのなら、その前にバックスラッシュを
付けるか、それを最初の文字として指定します。たとえば、パターン
 \regexp{[]]} は \code{']'} とマッチします。

範囲内にない文字とは、その集合の\dfn{補集合をとること}で
マッチすることができます。これは、集合の最初の文字として
\character{\textasciicircum} を含めることで表すことができます；
他の場所にある \character{\textasciicircum}は、単純に
\character{\textasciicircum}文字とマッチするだけです。例えば、
\regexp{[{\textasciicircum}5]} は、
\character{5}以外の任意の文字とマッチし、
\regexp{[\textasciicircum\code{\textasciicircum}]} は、
 \character{\textasciicircum} 以外の任意の文字とマッチします。

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

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

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

\item[\code{(?iLmsux)}] ( 集合 \character{i}、\character{L}、
\character{m}、 \character{s}、\character{u}、\character{x}
から1文字以上)。グループは空文字列ともマッチします；文字は、
正規表現全体の対応するフラグ (\constant{re.I}、 \constant{re.L}、
\constant{re.M}、 \constant{re.S}、
\constant{re.U}、 \constant{re.X} ) を設定します。
これはもし\var{flag} 引数を\function{compile()}
関数に渡さずに、そのフラグを正規表現の一 部として含めたいならば 役に立ちます。

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

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

\item[\code{(?P<\var{name}>...)}] 正規表現の丸括弧と同様ですが、
グループによってマッチされたサブ文字列は、記号グループ名
 \var{name}を介してアクセスできます。グループ名は、正しい Python
 識別子でなければならず、各グループ名は、正規表現内で一度だけ定義され
 なければなりません。記号グループは、グループに名前が付けられていない場合のように、
 番号付けされたグループでもあります。そこで上の例で 'id'という名前がついた
 グループは、番号グループ 1 として参照することもできます。

たとえば、もしパターンが
\regexp{(?P<id>[a-zA-Z_]\e w*)}であれば、このグループは、
マッチオブジェクトのメソッドへの引数に、
\code{m.group('id')} あるいは \code{m.end('id')}のような名前で、
またパターンテキスト内(例えば、 \regexp{(?P=id)}) や
置換テキスト内( \code{\e g<id>}のように) で名前で参照することができます。

\item[\code{(?P=\var{name})}] 前に \var{name} と名前付けされたグループに
マッチした、いかなるテキストにもマッチします。

\item[\code{(?\#...)}] コメントです；括弧の内容は
単純に無視されます。

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

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

\item[\code{(?<=...)}] もし文字列内の現在位置の前に、
現在位置で終わる \regexp{...} とのマッチがあれば、マッチします。
これは \dfn{肯定後読みアサーション(positive lookbehind assertion)}と呼ばれます。
\regexp{(?<=abc)def} は、\samp{abcdef} にマッチを見つけます、
というのは後読みが3文字をバックアップして、含まれているパターンと
マッチするかどうか検査するからです。含まれるパターンは、
固定長の文字列にのみマッチしなければなりません、ということは、
\regexp{abc} や \regexp{a|b} は許されますが、
\regexp{a*} や \regexp{a\{3,4\}} は許されないことを意味します。
肯定後読みアサーションで始まるパターンは、検索される文字列の
先頭とは決してマッチしないことに注意して下さい；
多分、\function{match()} 関数よりは \function{search()}関数を使いたいでしょう：

\begin{verbatim}
>>> import re
>>> m = re.search('(?<=abc)def', 'abcdef')
>>> m.group(0)
'def'
\end{verbatim}

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

\begin{verbatim}
>>> m = re.search('(?<=-)\w+', 'spam-egg')
>>> m.group(0)
'egg'
\end{verbatim}

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

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

\end{description}

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

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

\item[\code{\e A}] 文字列の先頭だけにマッチします。

\item[\code{\e b}] 空文字列とマッチしますが、単語の先頭か末尾の時だけです。
単語は英数字あるいは下線文字の並んだものとして定義されていますので、単語の末尾は
空白あるいは非英数字、非下線文字によって表されます。
{}\code{\e b} は、\code{\e w} と \code{\e W}の間の境界として定義されているので、
英数字であると見なされる文字の正確な集合は、\code{UNICODE}と\code{LOCALE}フラグの
値に依存することに注意して下さい。
文字の範囲の中では、\regexp{\e b} は、
Python の文字列リテラルと互換性を持たせるために、
 後退(backspace)文字を表します。

\item[\code{\e B}] 空文字列とマッチしますが、それが単語の先頭あるいは末尾に
\emph{ない}時だけです。これは {}\code{\e b}のちょうど反対ですので、
\code{LOCALE} と\code{UNICODE}の設定にも影響されます。

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

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

\item[\code{\e s}] \constant{LOCALE} と \constant{UNICODE} フラグが
指定されていない場合、任意の空白文字とマッチします；これは
集合 \regexp{[ \e t\e n\e r\e f\e v]}と同じ意味です。

\constant{LOCALE} がある場合、これはこの集合に加えて現在のロケールで
空白と定義されている全てにマッチします。\constant{UNICODE} が設定されると、
これは \regexp{[ \e t\e n\e r\e f\e v]} と Unicode 文字特性データベースで
空白と分類されている全てにマッチします。

\item[\code{\e S}] \constant{LOCALE} と \constant{UNICDOE} がフラグが
指定されていない場合、任意の非空白文字とマッチします；これは
集合 \regexp{[\textasciicircum\ \e t\e n\e r\e f\e v]} と同じ意味です。
\constant{LOCALE} がある場合、これはこの集合に無い文字と、現在の
ロケールで空白と定義されていない文字にマッチします。\constant{UNICODE} が
設定されていると、\regexp{[ \e t\e n\e r\e f\e v]} でない文字と、
Unicode 文字特性データベースで空白とマーク付けされていないものに
マッチします。

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

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

\item[\code{\e Z}] 文字列の末尾とのみマッチします。

\end{description}

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

\begin{verbatim}
\a      \b      \f      \n
\r      \t      \v      \x
\\
\end{verbatim}

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

% セクションタイトルにピリオドがないことに注意すること；それがあると
% GNU info バージョンの読者に問題が発生します。http://www.python.org/sf/581414 を見て下さい。
\subsection{マッチング vs 検索 \label{matching-searching}}
\sectionauthor{Fred L. Drake, Jr.}{fdrake@acm.org}

Python は、正規表現に基づく、2つの異なるプリミティブな操作を
提供しています：マッチと検索です。もしあなたが Perl の記号に慣れているのであれば、
検索操作があなたの求めるものです。 \function{search()} 関数と、
コンパイルされた正規表現オブジェクトでの
対応するメソッドを見て下さい。

マッチは、\character{\textasciicircum}で始まる正規表現を使うと、検索とは
異なるかもしれないことに注意して下さい：
\character{\textasciicircum} は文字列の先頭でのみ、あるいは
 \constant{MULTILINE} モードでは改行の直後ともマッチします。
``マッチ'' 操作は 、もしそのパターンが、モードに拘らず文字列の先頭とマッチ
するか、あるいは改行がその前にあるかどうかに拘らず、省略可能な
\var{pos} 引数によって
与えられる先頭位置でマッチする場合のみ成功します。

% Tim Peters の例題：
\begin{verbatim}
re.compile("a").match("ba", 1)           # 成功
re.compile("^a").search("ba", 1)         # 失敗； 'a' は先頭にない
re.compile("^a").search("\na", 1)        # 失敗； 'a' は先頭にない
re.compile("^a", re.M).search("\na", 1)  # 成功
re.compile("^a", re.M).search("ba", 1)   # 失敗； \n が前にない
\end{verbatim}


\subsection{モジュール コンテンツ}
\nodename{Contents of Module re}

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

\begin{funcdesc}{compile}{pattern\optional{, flags}}
 正規表現パターンを正規表現オブジェクトにコンパイルします。
 このオブジェクトは、以下で述べる \function{match()} と
  \function{search()} メソッドを使って、マッチングに使うことが
  できます。

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

シーケンス

\begin{verbatim}
prog = re.compile(pat)
result = prog.match(str)
\end{verbatim}

は、

\begin{verbatim}
result = re.match(pat, str)
\end{verbatim}

と同じ意味ですが、\function{compile()} を使うバージョンの方が、
その式を一つのプログラムで何回も使う時にはより効率的です。
%( \function{re.match()} あるいは \function{re.search()}へ渡す
%最後のパターンをコンパイルしたバージョンはキャッシュされます。だから
%一度に一つの正規表現だけしか使用しないプログラムは、正規表現の
%コンパイルについて心配する必要はありません。)
\end{funcdesc}

\begin{datadesc}{I}
\dataline{IGNORECASE}
大文字・小文字を区別しないマッチングを実行します； \regexp{[A-Z]}のような式は、
小文字にもマッチします。これは現在のロケールには
影響されません。
\end{datadesc}

\begin{datadesc}{L}
\dataline{LOCALE}
\regexp{\e w}、 \regexp{\e W}、 \regexp{\e b}および、\regexp{\e B}、
\regexp{\e s} と \regexp{\e S} を、現在のロケールに従わさせます。
\end{datadesc}

\begin{datadesc}{M}
\dataline{MULTILINE}
指定されると、パターン文字 \character{\textasciicircum} は、
文字列の先頭および各行の先頭(各改行の直後)とマッチします；そして
パターン文字 \character{\$} は文字列の末尾および各行の末尾
(改行の直前)とマッチします。デフォールトでは、
\character{\textasciicircum} は、
文字列の先頭とだけマッチし、
\character{\$}は、文字列の末尾および文字列の末尾の
改行の直前(がもしあれば)とマッチします。
\end{datadesc}

\begin{datadesc}{S}
\dataline{DOTALL}
 特殊文字 \character{.} を、改行をを含む任意の文字と、とにかくマッチ
 させます；このフラグがなければ、\character{.} は、改行 \emph{以外の}
任意の文字とマッチします。
\end{datadesc}

\begin{datadesc}{U}
\dataline{UNICODE}
\regexp{\e w}、 \regexp{\e W}、 \regexp{\e b}、 \regexp{\e B}、
\regexp{\e d}、 \regexp{\e D}、 \regexp{\e s} と \regexp{\e S} を、
Unicode 文字特性データベースに従わさせます。
\versionadded{2.0}
\end{datadesc}

\begin{datadesc}{X}
\dataline{VERBOSE}
このフラグによって、より見やすく正規表現を書くことができます。
パターン内の空白は、文字クラス内にあるか、エスケープされていない
バックスラッシュが前にある時以外は無視されます。
また、行に、文字クラス内にもなく、エスケープされていない
バックスラッシュが前にもない \character{\#} がある時は、
そのような \character{\#}の左端から
その行の末尾までが無視されます。
% XXX はここに例題を追加すべきです。
\end{datadesc}


\begin{funcdesc}{search}{pattern, string\optional{, flags}}
  \var{string}全体を走査して、正規表現 \var{pattern} がマッチを発生する
  位置を探して、対応する \class{MatchObject} インスタンスを返します。
  もし文字列内に、そのパターンとマッチする位置がないならば、
  \code{None} を返します；
  これは、文字列内のある点で長さゼロのマッチ
  を探すこととは異なることに注意して下さい。
\end{funcdesc}

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

  \note{もし \var{string} のどこかにマッチを位置付けたいのであれば、
  代わりに \method{search()} を使って下さい。}
\end{funcdesc}

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

\begin{verbatim}
>>> 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.']
\end{verbatim}
\end{funcdesc}

\begin{funcdesc}{findall}{pattern, string\optional{, flags}}
\var{pattern} の\var{string} へのマッチのうち、重複しない全てのマッチ
からなるリストを返します。パターン中に何らかのグループがある場合、グルー
プのリストを返します。グループが複数定義されていた場合、タプルのリスト
になります。他のマッチの開始部分に接触しないかぎり、空のマッチも結果に
含められます。
  \versionadded{1.5.2}
  \versionchanged[オプションの flags 引数を追加しました]{2.4}
\end{funcdesc}

\begin{funcdesc}{finditer}{pattern, string\optional{, flags}}
  \var{string} 内の RE \var{pattern}の重複しないマッチのすべての
  イテレータを返します。各マッチごとに、イテレータはマッチ
  オブジェクトを返します。他にマッチがなければ、
  空のマッチも結果に入ります。
  \versionadded{2.2}
  \versionchanged[Added the optional flags argument]{2.4}
\end{funcdesc}

\begin{funcdesc}{sub}{pattern, repl, string\optional{, count}}
  \var{string} 内で、 \var{pattern}と重複しないマッチの内、一番左にあるものを
  置換 \var{repl} で置換して得られた文字列を返します。もしパターンが
  見つからなければ、\var{string} を変更せずに返します。
   \var{repl} は文字列でも関数でも構いません；もしそれが文字列であれば、
  それにある任意のバックスラッシュエスケープは処理されます。すなわち、
  \samp{\e n} は単一の改行文字に変換され、\samp{\e r}は、
  行送りコードに変換されます、等々。
  \samp{\e j} のような未知のエスケープはそのままにされます。
  \samp{\e6}のような後方参照(backreference)は、パターンのグループ 6 とマッチ
  したサブ文字列で置換されます。
  例えば：

\begin{verbatim}
>>> 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{'
\end{verbatim}

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

\begin{verbatim}
>>> def dashrepl(matchobj):
...     if matchobj.group(0) == '-': return ' '
...     else: return '-'
>>> re.sub('-{1,2}', dashrepl, 'pro----gram-files')
'pro--gram files'
\end{verbatim}

  パターンは、文字列でも RE でも構いません；もし正規表現フラグを指定する
  必要があれば、RE オブジェクトを使うか、パターンに埋込み修飾子を使わ
  なければなりません；たとえば、\samp{sub("(?i)b+", "x", "bbbb
  BBBB")} は \code{'x x'} を返します。

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

  上で述べた文字エスケープや後方参照の他に、 \samp{\e g<name>} は、
    \regexp{(?P<name>...)} のシンタクスで定義されているように、
   \samp{name} という名前のグループとマッチしたサブ文字列を
   使います。\samp{\e g<number>} は対応するグループ番号を使います；
   それゆえ \samp{\e g<2>} は \samp{\e 2}と同じ意味ですが、
   \samp{\e g<2>0} のような置換でもあいまいではありません。 \samp{\e 20} は、
   グループ 20 への参照として解釈されますが、グループ 2 にリテラル文字
   \character{0} が続いたものへの参照としては解釈されません。
   後方参照  \samp{\e g<0>} は、
   RE とマッチするサブ文字列全体を置き換えます。
\end{funcdesc}

\begin{funcdesc}{subn}{pattern, repl, string\optional{, count}}
   \function{sub()} と同じ操作を行いますが、タプル
  \code{(\var{new_string}、 \var{number_of_subs_made})}を返します。
\end{funcdesc}

\begin{funcdesc}{escape}{string}
  バックスラッシュにすべての非英数字をつけた\var{string}を返します；これは
  もし、その中に正規表現のメタ文字を持つかもしれない任意のリテラル文字列と
  マッチしたいとき、役に立ちます。
\end{funcdesc}

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


\subsection{正規表現オブジェクト \label{re-objects}}

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

\begin{methoddesc}[RegexObject]{match}{string\optional{, pos\optional{,
                                       endpos}}}
  もし \var{string}の先頭の 0 個以上の文字がこの正規表現とマッチすれば、
  対応する \class{MatchObject} インスタンスを返します。
  もし文字列がパタンーとマッチしなければ、\code{None} を返します；
  これは長さゼロのマッチとは異なることに
  注意して下さい。

  \note{もしマッチを \var{string} のどこかに位置付けたければ、
  代わりに \method{search()} を使って下さい。}

  省略可能な第2のパラメータ \var{pos}は、文字列内の検索を始めるインデッスクを
  与えます；デフォールトでは \code{0} です。これは、文字列のスライシングと
  完全に同じ意味だというわけではありません；\code{'\textasciicircum'}
  パターン文字は、
  文字列の実際の先頭と改行の直後とマッチしますが、
  それが必ずしも検索が開始するインデックスであるわけでは
  ないからです。

  省略可能なパラメータ \var{endpos}は、どこまで文字列が検索されるかを
  制限します；あたかもその文字列が \var{endpos} 文字長であるかのように
  しますので、 \var{pos} から \code{\var{endpos} - 1} までの文字が、
  マッチのために検索されます。もし \var{endpos} が \var{pos}より小さければ、
  マッチは見つかりませんが、そうでなくて、もし\var{rx} がコンパイルされた
  正規表現オブジェクトであれば、
  \code{\var{rx}.match(\var{string}, 0, 50)} は
  \code{\var{rx}.match(\var{string}[:50], 0)}と同じ意味になります。
\end{methoddesc}

\begin{methoddesc}[RegexObject]{search}{string\optional{, pos\optional{,
                                        endpos}}}
  \var{string}全体を走査して、この正規表現がマッチする位置を探して、
  対応する \class{MatchObject} インスタンスを返します。もし文字列内に
  パターンとマッチする位置がないならば、\code{None} を返します；
  これは文字列内のある点で長さゼロのマッチを探すこととは異なることに
  注意して下さい。

  省略可能な \var{pos} と \var{endpos} パラメータは、
   \method{match()} メソッドのものと同じ意味を持ちます。
\end{methoddesc}

\begin{methoddesc}[RegexObject]{split}{string\optional{,
                                       maxsplit\code{ = 0}}}
 \function{split()} 関数と同様で、コンパイルしたパターンを使います。
\end{methoddesc}

\begin{methoddesc}[RegexObject]{findall}{string\optional{, pos\optional{,
                                        endpos}}}
 \function{findall()} 関数と同様で、コンパイルしたパターンを使います。
\end{methoddesc}

\begin{methoddesc}[RegexObject]{finditer}{string\optional{, pos\optional{,
                                        endpos}}}
 \function{finditer()} 関数と同様で、コンパイルしたパターンを使います。
\end{methoddesc}

\begin{methoddesc}[RegexObject]{sub}{repl, string\optional{, count\code{ = 0}}}
 \function{sub()} 関数と同様で、コンパイルしたパターンを使います。
\end{methoddesc}

\begin{methoddesc}[RegexObject]{subn}{repl, string\optional{,
                                      count\code{ = 0}}}
 \function{subn()} 関数と同様で、コンパイルしたパターンを使います。
\end{methoddesc}


\begin{memberdesc}[RegexObject]{flags}
flags 引数は、RE オブジェクトがコンパイルされたとき使われ、
もし flags が何も提供されなければ \code{0} です。
\end{memberdesc}

\begin{memberdesc}[RegexObject]{groupindex}
\regexp{(?P<\var{id}>)}で定義された任意の記号グループ名の、グループ番号
への辞書マッピングです。もし記号グループが
パターン内で何も使われていなければ、辞書は空です。
\end{memberdesc}

\begin{memberdesc}[RegexObject]{pattern}
RE オブジェクトがそれからコンパイルされたパターン文字列です。
\end{memberdesc}


\subsection{MatchObject オブジェクト \label{match-objects}}

\class{MatchObject} インスタンスは以下のメソッドと属性を
サポートします：

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

\begin{methoddesc}[MatchObject]{group}{\optional{group1, \moreargs}}
マッチした1個以上のサブグループを返します。もし引数で一つであれば、
その結果は一つの文字列です；複数の引数があれば、その結果は、
引数ごとに一項目を持つタプルです。引数がなければ、
 \var{group1} はデフォールトでゼロです(マッチしたものすべてが
返されます)。
もし \var{groupN} 引数がゼロであれば、対応する戻り値は、マッチ
する文字列全体です；もしそれが範囲 [1..99] 内であれば、それは、対応する
丸括弧つきグループとマッチする文字列です。もしグループ番号が負であるか、
あるいはパターンで定義されたグループの数より大きければ、
\exception{IndexError} 例外が発生します。もしグループがマッチしなかった
パターンの一部に含まれていれば、対応する結果は \code{None} です。
もしグループが、複数回マッチしたパターンの一部に
含まれていれば、
最後のマッチが返されます。

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

適度に複雑な例題：

\begin{verbatim}
m = re.match(r"(?P<int>\d+)\.(\d*)", '3.14')
\end{verbatim}

このマッチを実行したあとでは、\code{m.group(1)} は
\code{m.group('int')} と同じく、\code{'3'} であり、そして\code{m.group(2)} は \code{'14'} です。
\end{methoddesc}

\begin{methoddesc}[MatchObject]{groups}{\optional{default}}
1からどれだけ多くであろうがパターン内にあるグループ数までの、
マッチの、すべてのサブグループを含むタプルを返します。
 \var{default} 引数は、マッチに加わらなかったグループ用に使われます；
 それはデフォールトでは \code{None} です。
 (非互換性ノート：オリジナルの Python 1.5 リリースでは、たとえタプルが一要素長で
 あっても、その代わりに文字列を返すことはありません。(1.5.1 以降の)後のバージョンでは、
 そのような場合には、シングルトンタプルが返されます。)
\end{methoddesc}

\begin{methoddesc}[MatchObject]{groupdict}{\optional{default}}
すべての \emph{名前つきの}サブグループを含む、マッチの、
サブグループ名でキー付けされた辞書を返します。
\var{default} 引数はマッチに加わらなかったグループ用に
使われます；それはデフォールトでは \code{None}です。
\end{methoddesc}

\begin{methoddesc}[MatchObject]{start}{\optional{group}}
\methodline[MatchObject]{end}{\optional{group}}
\var{group}とマッチしたサブ文字列の先頭と末尾のインデックスを
返します；\var{group} は、デフォールトでは (マッチしたサブ文字列
全体を意味する）ゼロです。
 \var{group} が存在してもマッチに寄与しなかった場合は、
\code{-1} を返します。マッチオブジェクト \var{m} および
マッチに寄与しなかったグループ \var{g}があって、
グループ \var{g} とマッチしたサブ文字列
( \code{\var{m}.group(\var{g})}と同じ意味ですが) は、

\begin{verbatim}
m.string[m.start(g):m.end(g)]
\end{verbatim}

です。
もし \var{group}がヌル文字列とマッチすれば、
\code{m.start(\var{group})}が \code{m.end(\var{group})} と等しくなろことに
注意して下さい。例えば、 \code{\var{m} = re.search('b(c?)', 'cba')}
の後では、\code{\var{m}.start(0)}は 1 で、 \code{\var{m}.end(0)} は 2 であり、
\code{\var{m}.start(1)} と \code{\var{m}.end(1)} はともに 2 であり、
\code{\var{m}.start(2)} は \exception{IndexError}例外を発生します。
\end{methoddesc}

\begin{methoddesc}[MatchObject]{span}{\optional{group}}
\class{MatchObject} \var{m} については、 2-タプル
\code{(\var{m}.start(\var{group})、 \var{m}.end(\var{group}))}を
返します。もし \var{group} がマッチに寄与しなかったら、これは
\code{(-1, -1)} です。また \var{group} はデフォールトでゼロです。
\end{methoddesc}

\begin{memberdesc}[MatchObject]{pos}
\class{RegexObject} の \function{search()} あるいは \function{match()} 
メソッドに渡された \var{pos}の値です。
これは RE エンジンがマッチを探し始める位置の文字列のインデックスです。
\end{memberdesc}

\begin{memberdesc}[MatchObject]{endpos}
\class{RegexObject} の \function{search()} あるいは \function{match()} 
メソッドに渡された \var{endpos}の値です。
これは RE エンジンがそれ以上は進まない位置の文字列のインデックスです。
\end{memberdesc}

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

\begin{memberdesc}[MatchObject]{lastgroup}
最後にマッチした取り込みグループの名前です。もしグループに名前がないか、
あるいはどのグループも全くマッチしなければ \code{None} です。
\end{memberdesc}

\begin{memberdesc}[MatchObject]{re}
その \method{match()}あるいは \method{search()} メソッドが、この
\class{MatchObject} インスタンスを生成した正規表現オブジェクトです。
\end{memberdesc}

\begin{memberdesc}[MatchObject]{string}
\function{match()} あるいは \function{search()}に渡された文字列です。
\end{memberdesc}

\subsection{例}

\leftline{\strong{\cfunction{scanf()}をシミュレートする}}

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

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

\begin{verbatim}
    /usr/sbin/sendmail - 0 errors, 4 warnings
\end{verbatim}

のような文字列からファイル名と数値を抽出するには、

\begin{verbatim}
    %s - %d errors, %d warnings
\end{verbatim}

のように \cfunction{scanf()}フォーマットを使うでしょう。
それと同等な正規表現は

\begin{verbatim}
    (\S+) - (\d+) errors, (\d+) warnings
\end{verbatim}


\leftline{\strong{再帰を避ける}}

エンジンに大量の再帰を要求するような正規表現を作成すると、
\code{maximum recursion limit exceeded(最大再帰制限を超過した)}
というメッセージを持つ \exception{RuntimeError} 例外に出くわすかもしれません。たとえば、

\begin{verbatim}
>>> import re
>>> s = "Begin" + 1000 * 'a very long string' + 'end'
>>> re.match('Begin (\w| )*? end', s).end()
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
  File "/usr/local/lib/python2.5/re.py", line 132, in match
    return _compile(pattern, flags).match(string)
RuntimeError: maximum recursion limit exceeded
\end{verbatim}

再帰を避けるように正規表現を組みなおせることはよくあります。

Python 2.3 からは、再帰を避けるために \regexp{*?} パターンの利用が
特別扱いされるようになりました。したがって、上の正規表現は
\regexp{Begin [a-zA-Z0-9_ ]*?end} に書き直すことで再帰を防ぐことが
できます。それ以上の恩恵として、そのような正規表現は、
再帰的な同等のものよりもより速く動作します。
