Chapter1   Pythonで実行

a+?

 先ず文字列パターンを、アルファベット1文字の a と +? を組み合わせて a+? とします。

これは a につき最小の繰り返しを表します。

対象文字列が map なら a にマッチするはずです。

    re_meta29_1.py

        import  re

        pattern = re.compile("a+?")
        st = "map"
        print("↓ 対象文字列\n"+st)
        result_iter = pattern.finditer(st)
        for  result   in  result_iter:
            print("match:",result.group())
            print("位置",result.span())        
                            

実行結果

 予想通り、a にマッチしました。

次にパターンを ma+?p にします。

m と p の間で a が最少で繰り返されている場合にのみ一致するはずです。

    re_meta29_2.py

        import  re

        pattern = re.compile("ma+?p")
        st = "mp map maap"
        print("↓ 対象文字列\n"+st)
        result_iter = pattern.finditer(st)
        for  result   in  result_iter:
            print("match:",result.group())
            print("位置",result.span())        
                            

実行結果

 この場合は、? が無い場合と等しい結果になりました。

? があっても、a を2回繰り返している maap に一致しました。

 これに対して、対象文字列を mop としてしまうと、a の代わりに o が存在するのでマッチしません。

    re_meta29_3.py

        import  re

        pattern = re.compile("ma+?p")
        st = "mop"
        print("↓ 対象文字列\n"+st)
        result_iter = pattern.finditer(st)
        for  result   in  result_iter:
            print("match:",result.group())
            print("位置",result.span())        
                            

実行結果

 mop ではマッチしない事が確認出来ました。

e*?   e+?   e??   e{1,3}*   e{1,}?   e{,3}?

 さて、ここで冒頭で例示した bee について実行してみましょう。

先ず *? です。

パターンを be*? と構成する事で、e に最小マッチさせます。

対象文字列が beeeeeee のように、e が多く繰り返されていてる場合でも、b までしかヒットしないはずです。

    re_meta29_4.py

        import  re

        pattern = re.compile("be*?")
        st = "b be bee beeeeeee"
        print("↓ 対象文字列\n"+st)
        result_iter = pattern.finditer(st)
        for  result   in  result_iter:
            print("match:",result.group())
            print("位置",result.span())        
                            

実行結果

実行結果(続き)

 想定通り、e が多く繰り返されていても b までしかヒットしていません。

次にパターンを be+? と構成して、+? を試してみます。

    re_meta29_5.py

        import  re

        pattern = re.compile("be+?")
        st = "b be bee beeeeeee"
        print("↓ 対象文字列\n"+st)
        result_iter = pattern.finditer(st)
        for  result   in  result_iter:
            print("match:",result.group())
            print("位置",result.span())        
                            

実行結果

 この場合は、be までのマッチになりました。

今度は ?? を実行してみましょう。

文字列パターンは be?? です。

    re_meta29_6.py

        import  re

        pattern = re.compile("be??")
        st = "b be bee beeeeeee"
        print("↓ 対象文字列\n"+st)
        result_iter = pattern.finditer(st)
        for  result   in  result_iter:
            print("match:",result.group())
            print("位置",result.span())        
                            

実行結果

実行結果(続き)

 b までのマッチになりました。

これは be*? と同様の結果です。

 では、be{1,3}? も試してみます。

    re_meta29_7.py

        import  re

        pattern = re.compile("be{1,3}?")
        st = "b be bee beeeeeee"
        print("↓ 対象文字列\n"+st)
        result_iter = pattern.finditer(st)
        for  result   in  result_iter:
            print("match:",result.group())
            print("位置",result.span())        
                            

実行結果

 e の1回分の繰り返しである be までマッチしました。

続いて、be{1,}? を実行します。

    re_meta29_8.py

        import  re

        pattern = re.compile("be{1,}?")
        st = "b be bee beeeeeee"
        print("↓ 対象文字列\n"+st)
        result_iter = pattern.finditer(st)
        for  result   in  result_iter:
            print("match:",result.group())
            print("位置",result.span())        
                            

実行結果

 結果は be{1,3}? のときと等しく、be までの一致です。

be{,3}? も確認します。

    re_meta29_9.py

        import  re

        pattern = re.compile("be{,3}?")
        st = "b be bee beeeeeee"
        print("↓ 対象文字列\n"+st)
        result_iter = pattern.finditer(st)
        for  result   in  result_iter:
            print("match:",result.group())
            print("位置",result.span())        
                            

実行結果

実行結果(続き)

 b までのマッチになりました。

be?? や be*? と同様、b までのマッチです。

p タグ1個分を取得する

 ここでは、もう少し実用的な例で検証します。

HTMLの pタグ(<p> </p>) 1個分を各々取得したいと思います。

対象文字列のpタグは2つ並んでいて、<p> </p><p> </p> のようになっている状態です。

このうち1個分のpタグを取得するには ? を用いて、<p>.*?</p>などと記述します。

(. は任意の1文字を表します。詳細は、【. 改行以外の任意の1文字】で詳しく説明しています。)

    re_meta29_10.py

        import  re

        pattern = re.compile("<p>.*?</p>")
        st = "<p>title</p><p>sub</p>"
        print("↓ 対象文字列\n"+st)
        result_iter = pattern.finditer(st)
        for  result   in  result_iter:
            print("match:",result.group())
            print("位置",result.span())        
                            

実行結果

 狙い通り、各々pタグを一つ分取得出来ました。

ちなみに、これを ? を付けないで実行するとどうなるかも確認しましょう。

    re_meta29_11.py

        import  re

        pattern = re.compile("<p>.*</p>")
        st = "<p>title</p><p>sub</p>"
        print("↓ 対象文字列\n"+st)
        result_iter = pattern.finditer(st)
        for  result   in  result_iter:
            print("match:",result.group())
            print("位置",result.span())        
                            

実行結果

 今度は、2つがまとまってマッチしました。

* が強欲にマッチする為です。

(es)+?

 今度は、グループ化されたものを繰り返しの対象とします。

グループを表す正規表現は ( ) です。

(グループ については【( ) グループを指定】で詳しく説明しています。)

パターンを (es) について最少回数の繰り返しにする場合、(es)+? のように記述します。

    re_meta29_12.py

        import  re

        pattern = re.compile("gen(es)+?")
        st = "gen genes geneses"
        print("↓ 対象文字列\n"+st)
        result_iter = pattern.finditer(st)
        for  result   in  result_iter:
            print("match:",result.group())
            print("位置",result.span())        
                            

実行結果

 それぞれ、es の一つ分の繰り返しである genes に一致しています。

 さらに、次の例では (es) の後方参照を試しています。

(後方参照 については【( ) キャプチャを使う】で詳しく説明しています。)

 パターンは、シンプルに (es)+?\1 にしましょう。

対象文字列は、先程と同様なものに geneseseses 加えた gen genes geneses geneseseses です。

    re_meta29_13.py

        import  re

        pattern = re.compile(r"gen(es)+?\1")
        st = "gen genes geneses geneseseses"
        print("↓ 対象文字列\n"+st)
        result_iter = pattern.finditer(st)
        for  result   in  result_iter:
            print("----- match -----")
            for  i   in  range(result.lastindex + 1):
              print('group{num};'.format(num = i),result.group(i))
              print("位置",result.span(i))
                            

実行結果

実行結果(続き)

 geneses , geneseseses の geneses の箇所 にはマッチしました。

グループに量指定子を組み合わせてから、後方参照を (es)+?\1 のように行っても、あくまで es と、その参照が必要になる事は変わらないようです。

((es)+?)

 次の例では、(es)+? 自体を ( ) で括ってグループ化してみましょう。

パターン以外は、一つ前に実行した meta29_13.py と同様にして試します。

    re_meta29_14.py

        import  re

        pattern = re.compile(r"gen((es)+?)\1")
        st = "gen genes geneses geneseseses"
        print("↓ 対象文字列\n"+st)
        result_iter = pattern.finditer(st)
        for  result   in  result_iter:
            print("----- match -----")
            for  i   in  range(result.lastindex + 1):
              print('group{num};'.format(num = i),result.group(i))
              print("位置",result.span(i))
                            

実行結果

実行結果(続き)

 geneses , geneseseses につき、各々最少回数の繰り返しに該当する後方参照が行われたようです。

なお、gen((es)+)\1 とした場合は、geneseseses につき2回分の繰り返しに対する後方参照が行われます。

\d+?

 続けて例を出します。

数字を表す文字クラスである \d と +? を組み合わせて、数字の繰り返しを狙います。

(文字クラス については【\d 数字を指定する】で詳しく説明します。)

    re_meta29_15.py

        import  re

        pattern = re.compile("¥\d+?")
        st = "¥ ¥7 ¥57 ¥287"
        print("↓ 対象文字列\n"+st)
        result_iter = pattern.finditer(st)
        for  result   in  result_iter:
            print("match:",result.group())
            print("位置",result.span())        
                            

実行結果

 ¥ 表示の金額を左から1桁分取得出来ました。