问题已解决

我在python中使用这个正则表达式，我在python手册中发现了这一点：

(?(id/name)yes-pattern|no-pattern) Will try to match with yes-pattern if the group with given id or name exists, and with no-pattern if it doesn’t. no-pattern is optional and can be omitted. For example, (<)?(w+@w+(?:.w+)+)(?(1)>) is a poor email matching pattern, which will match with as well as user@host.com , but not with

2.4版中的新增功能。

所以我的最终答案是：

r (?P<prefix>A)?(?P<key>S+)(?(prefix)|B) 

命令：

>>>re.sub(r (?P<prefix>A)?(?P<key>S+)(?(prefix)|B) , g<key> ,"Aanything")

任何东西

>>>re.sub(r (?P<prefix>A)?(?P<key>S+)(?(prefix)|B) , g<key> ,"anythingB")

任何东西

虽然AanythingB把anythingB还给我，但我无论如何都不在乎。

>>>re.sub(r (?P<prefix>A)?(?P<key>S+)(?(prefix)|B) , g<key> ,"AanythingB")

任何东西B

(^A.*B$)|(^A.*$)|(^.*B$)

这是想要的行为吗？

var rx = /^((?:A)?)(.*?)((?:B)?)$/;
"Aanything".match(rx)
> ["Aanything", "A", "anything", ""]
"anythingB".match(rx)
> ["anythingB", "", "anything", "B"]
"AanythingB".match(rx)
> ["AanythingB", "A", "anything", "B"]
"anything".match(rx)
> ["anything", "", "anything", ""]
"AanythingB".replace(rx,  $1nothing$3 );
> "AnothingB"
"AanythingB".replace(rx,  $2 );
> "anything"

^A|B$或^ A|.*B$（取决于匹配函数是否从一开始就匹配）

UPDATE

很难为此编写一个正则表达式。。

一种可能性是：

match = re.match(r ^(?:A(S+))|(?:(S+)B)$ , string)
if match:
    capture = max(match.groups())
# because match.groups() is either (capture, None) or (None, capture)

试试这个：

/(^A|B$)/

如果您不介意前缀“A”和后缀“B”都存在的情况下的额外权重，您可以使用较短的正则表达式：

reMatcher= re.compile(r"(?<=AA).*|.*(?=B)")

（对于^使用A，对于$则使用）

当“A”和“B”都在各自的拐角处时，这个保持“A”前缀（而不是解决方案的“B”前缀）：

 A text here  matches   text here 
 more text hereB  matches  more text here 
 AYES!B  matched  AYES! 
 neither  doesn t match

否则，非正则表达式的解决方案（有些人会说是更“Python”的解决方案）是：

def strip_prefix_suffix(text, prefix, suffix):
    left =  len(prefix) if text.startswith(prefix) else 0
    right= -len(suffix) if text.endswith(suffix) else None
    return text[left:right] if left or right else None

如果不匹配，函数将返回None，以区别于可能的（例如，当被调用为strip_refix_fsuffix（AB，a，B）时）。

PS我还应该说，这个正则表达式：

(?<=AA).*(?=B)|(?<=AA).*|.*(?=B)

应该工作，但没有；它的工作原理和我建议的一样，我不明白为什么。将正则表达式分解为多个部分，我们可以看到一些奇怪的东西：

>>> text=  AYES!B 
>>> re.compile( (?<=\AA).*(?=B\Z) ).search(text).group(0)
 YES! 
>>> re.compile( (?<=\AA).* ).search(text).group(0)
 YES!B 
>>> re.compile( .*(?=B\Z) ).search(text).group(0)
 AYES! 
>>> re.compile( (?<=\AA).*(?=B\Z)|(?<=\AA).* ).search(text).group(0)
 YES! 
>>> re.compile( (?<=\AA).*(?=B\Z)|.*(?=B\Z) ).search(text).group(0)
 AYES! 
>>> re.compile( (?<=\AA).*|.*(?=B\Z) ).search(text).group(0)
 AYES! 
>>> re.compile( (?<=\AA).*(?=B\Z)|(?<=\AA).*|.*(?=B\Z) ).search(text).group(0)
 AYES! 

出于某种奇怪的原因，.*（？=B\Z）子表达式优先，尽管它是最后一个替代表达式。