使用正则表达式在每个匹配项中查找和替换任意数量的元素

Question

My goal is to recognize bold parenthesized text in a markup language, eg.:

[B] blah blah (foo) blah [/B]

and use regex to surround it with another tag, like so:

[B] blah blah [C](foo)[/C] blah [/B]

Here's my attempt at this using Python:

outtext = re.sub(r'(\[B\].*?)(\(.*?\))(.*?\[/B\])', r'\1[C]\2[/C]\3', intext)

The problem is, it doesn't work if there are multiple parenthesized strings within the block:

Input: [B] (foo) (bar) [/B]
Expected: [B] [C](foo)[/C] [C](bar)[/C] [/B]
Actual: [B] [C](foo)[/C] (bar) [/B]

I know the reason why this is happening, but I don't know how to fix it. Is it possible to change my regex so that it's able to find-and-replace an arbitrary number of parenthesized strings within each block, as opposed to just one?

Answer 1

First I thought regex alone is not capable of solving the problem. JvdV prooved this wrong, well done. Honestly, I do not understand this regex anymore.

I solved it with some easier regex and a bit of python

import re

intext = '[B] (foo) (bar) [/B] (not) [B] (this again) [/B]'

boldParts = re.findall(r'\[B\].*?\[/B\]', intext)
outtext = intext
for part in boldParts:
    replacement = re.sub(r'(\(.*?\))', r'[C]\1[/C]', part)
    outtext = outtext.replace(part, replacement)

print(outtext)

First I look for only the bold parts in the intext, then it's easy to replace the thing in parentheses. And replace it in the outtext again.

Admittedly not the shortest or most elegant way of doing it, but maybe a little more readable.

Answer 2

This kind of problem is typically resolved by replacing matches only inside other matches. You need to run a re.sub with a regex that will match all B tagged substrings, and replace multiple occurrences of strings between parentheses only inside those matches using a callable in re.sub as a replacement argument.

Here is the solution:

import re
text = "[B] blah blah (foo) blah [/B]\n[B] (foo) (bar) [/B]"
print(re.sub(r'(?s)\[B].*?\[/B]', lambda x: re.sub(r'\([^()]*\)', r'[C]\g<0>[/C]', x.group()), text))

See the Python demo .

NOTE : If you have longer texts, unroll the lazy dot pattern and use

r'\[B][^[]*(?:\[(?!/?B])[^[]*)*\[/B]'

See this regex demo .

Output:

[B] blah blah [C](foo)[/C] blah [/B]
[B] [C](foo)[/C] [C](bar)[/C] [/B]

The (?s)\\[B].*?\\[/B] pattern matches [B] , then 0+ chars as few as possible up to the leftmost [/B] (note (?s) allows the . to match any char including line break chars). Then, once a match is found, it is passed to the callable, and the \\([^()]*\\) regex is run on that match. \\([^()]*\\) matches any substring between the closest parentheses, ie ( , then 0+ chars other than ( and ) and then ) . The \\g<0> in the replacement pattern is a replacement backreference to the whole match.

Answer 3

Okay.. this took me some time.. I'm not sure of the specifics of the markup syntax, but I'll make some assumptions: the text inside parenthesis can be any character except parenthesis unless they are escaped. The escape character is a backslash. With that said.. here's what I came up with.

>>> expr = r"""
...    \(                            # Match left paren.
...       (
...         (?:      [^ \( \) \\] |  # Match any char not a paren or escape, OR
...              \\  [  \( \) \\] |  # Match an escaped paren or escape, OR
...              \s                  # whitespace.
...          )*
...        )
...    \)                            # Match right paren. """
...
>>> re.sub(expr, r"[C](\1)[/C]",  "[B] (foo) (bar) [/B]", flags=re.VERBOSE)
'[B] [C](foo)[/C] [C](bar)[/C] [/B]'

This will also work with target strings that have escaped parenthesis in them. The abbreviated form of the above is this...

re.sub(r"\(((?:[^\(\)\\]|\\[\(\)\\]|\s)*)\)", 
       r"[C](\1)[/C]",  "[B] (foo) (bar) [/B]")

With the whitespace and comments taken out...