如何创建一个找到第一个内部对词的正则表达式？

Question

I would like to make a regular expression which capture the first inner pair words. My code following works in a condition but it does not work in another. It captures the last pair words.

Please see the my code below.

def testReplaceBetweenWords():

    head_dlmt='Head'
    tail_dlmt='Tail'

    line0 = "abc_Head_def_Head_inner_inside_Tail_ghi_Tail_jkl"
    line1 = "abc_Head_first_Tail_ghi_Head_second_Tail_opq"

    between_pattern = "(^.*(?<={0}))(?!.*{0}).*?(?={1})(.*)$".format(head_dlmt, tail_dlmt)
    compiled_pattern = re.compile(between_pattern)

    # Case 0: good case: It captures the first inner words.    
    result0 = re.search(compiled_pattern, line0)  

    print("original 0    : {0}".format(result0.group(0)))
    print("expected Head : abc_Head_def_Head")
    print("found Head    : {0}".format(result0.group(1)))
    print("expected Tail :                                Tail_ghi_Tail_jkl")
    print("found Tail    : {0}{1}".format(' ' * (result0.regs[2][0]), result0.group(2)))

    print()

    # Case 1: Bad case: It captures the last pair words.    
    result1 = re.search(compiled_pattern, line1)

    print("original 1    : {0}".format(result1.group(0)))
    print("expected Head : abc_Head")
    print("found Head    : {0}".format(result1.group(1)))
    print("expected Tail :                Tail_ghi_Head_second_Tail_opq")
    print("found Tail    : {0}{1}".format(' ' * (result1.regs[2][0]), result1.group(2)))

And the outputs are following.

original 0    : abc_Head_def_Head_inner_inside_Tail_ghi_Tail_jkl
expected Head : abc_Head_def_Head
found Head    : abc_Head_def_Head
expected Tail :                                Tail_ghi_Tail_jkl
found Tail    :                                Tail_ghi_Tail_jkl

original 1    : abc_Head_first_Tail_ghi_Head_second_Tail_opq
expected Head : abc_Head
found Head    : abc_Head_first_Tail_ghi_Head
expected Tail :                Tail_ghi_Head_second_Tail_opq
found Tail    :                                     Tail_opq

The first case works well. It captures the first inner pair words. The second case does not work. It captures the last pair words but I expected the first pair words. How can I make a regular express which satisfies the two cases above?

Thank you very much.

Answer 1

Use the following regex:

between_pattern = "^((?:(?!{1}).)*{0}).*?({1}.*)$".format(head_dlmt, tail_dlmt)

See the online Python demo and the regex demo .

Details

• The first .* pattern should be replace with a tempered greedy token (?:(?!{1}).)* that matches any 0+ chars that do not start the end delimiter character sequence (thus, you may up to the last Head that contains no Tail )
• There is no point using lookarounds inside capturing groups as these patterns will be part of those capturing groups

Note you may want to compile the regex with re.S flag to support strings with line breaks.

Answer 2

Another option could be just match ( almost ) exactly what you want to match:

use this regex, and extract the first match:

(?<=Head)(?:(?!Head|Tail).)+(?=Tail)

in your case, use:

between_pattern = '(?<={0})(?:(?!{0}|{1}).)+(?={1})'.format(head_dlmt, tail_dlmt)

Even more: with this regex, you can extract the second, the third... the nth, just as easy as extract the first, and without any changes at all: it's more flexible.

see here:

https://regex101.com/r/ds90y4/1/