`match = re.match(); 的替代方案 如果匹配：...` 习语？

Question

如果你想检查某些内容是否与正则表达式匹配，如果是，则打印第一组，你可以这样做。

import re
match = re.match("(\d+)g", "123g")
if match is not None:
    print match.group(1)

这完全是迂腐的，但是中间的 match 变量有点烦人。

像 Perl 这样的语言会这样做这是通过为匹配组创建新的 $1..$9 变量来实现的，例如......

if($blah ~= /(\d+)g/){
    print $1
}

来自 这个 reddit 评论，

with re_context.match('^blah', s) as match:
    if match:
        ...
    else:
        ...

..我认为这是一个有趣的想法，所以我写了一个简单的实现：（

#!/usr/bin/env python2.6
import re

class SRE_Match_Wrapper:
    def __init__(self, match):
        self.match = match

    def __exit__(self, type, value, tb):
        pass

    def __enter__(self):
        return self.match

    def __getattr__(self, name):
        if name == "__exit__":
            return self.__exit__
        elif name == "__enter__":
            return self.__name__
        else:
            return getattr(self.match, name)

def rematch(pattern, inp):
    matcher = re.compile(pattern)
    x = SRE_Match_Wrapper(matcher.match(inp))
    return x
    return match

if __name__ == '__main__':
    # Example:
    with rematch("(\d+)g", "123g") as m:
        if m:
            print(m.group(1))

    with rematch("(\d+)g", "123") as m:
        if m:
            print(m.group(1))

理论上这个功能可以修补到_sre.SRE_Match 对象）

如果没有匹配项，如果您可以跳过 with 语句的代码块的执行，那就太好了，这会将其简化为

with rematch("(\d+)g", "123") as m:
    print(m.group(1)) # only executed if the match occurred

...。 .但这似乎是不可能的，根据我可以从 PEP 343 推断出的

任何想法？ 正如我所说，这确实是微不足道的烦恼，几乎达到了代码高尔夫的地步。

Answer 1

我不认为使用 with 是这种情况下的解决方案。 您必须在 BLOCK 部分（由用户指定）引发异常，并让 __exit__ 方法将 True 返回到“吞下”例外。 所以它永远不会好看。

我建议采用类似于 Perl 语法的语法。 制作您自己的扩展 re 模块（我将其称为 rex）并让它在其模块命名空间中设置变量：

if rex.match('(\d+)g', '123g'):
    print rex._1

正如您在下面的注释中看到的，此方法是既不是范围安全的，也不是线程安全的。 仅当您完全确定您的应用程序将来不会成为多线程，并且从您使用此功能的范围调用的任何函数也将使用相同的功能时，您才会使用此功能方法。

Answer 2

这看起来并不漂亮，但您可以从 getattr(object, name[, default]) 内置函数中受益，如下所示：

>>> getattr(re.match("(\d+)g", "123g"), 'group', lambda n:'')(1)
'123'
>>> getattr(re.match("(\d+)g", "X23g"), 'group', lambda n:'')(1)
''

模仿 if match 打印组流程，你可以这样使用for语句：

>>> for group in filter(None, [getattr(re.match("(\d+)g", "123g"), 'group', None)]):
        print(group(1))
123
>>> for group in filter(None, [getattr(re.match("(\d+)g", "X23g"), 'group', None)]):
        print(group(1))
>>> 

当然你可以定义一个小函数来完成肮脏的工作：

>>> matchgroup = lambda p,s: filter(None, [getattr(re.match(p, s), 'group', None)])
>>> for group in matchgroup("(\d+)g", "123g"):
        print(group(1))
123
>>> for group in matchgroup("(\d+)g", "X23g"):
        print(group(1))
>>> 

Answer 3

这不是完美的解决方案，但确实允许您为同一字符串链接多个匹配选项：

class MatchWrapper(object):
  def __init__(self):
    self._matcher = None

  def wrap(self, matcher):
    self._matcher = matcher

  def __getattr__(self, attr):
    return getattr(self._matcher, attr)

def match(pattern, s, matcher):
  m = re.match(pattern, s)
  if m:
    matcher.wrap(m)
    return True
  else:
    return False

matcher = MatchWrapper()
s = "123g";
if _match("(\d+)g", line, matcher):
  print matcher.group(1)
elif _match("(\w+)g", line, matcher):
  print matcher.group(1)
else:
  print "no match"

Answer 4

这是我的解决方案：

import re

s = 'hello world'

match = []
if match.append(re.match('w\w+', s)) or any(match):
    print('W:', match.pop().group(0))
elif match.append(re.match('h\w+', s)) or any(match):
    print('H:', match.pop().group(0))
else:
    print('No match found')

您可以根据需要使用任意多个 elif 子句。

更好的是：

import re

s = 'hello world'

if vars().update(match=re.match('w\w+', s)) or match:
    print('W:', match.group(0))
elif vars().update(match=re.match('h\w+', s)) or match:
    print('H:', match.group(0))
else:
    print('No match found')

追加和更新都返回无。 因此，您必须在每种情况下使用或部分来实际检查表达式的结果。

不幸的是，只有当代码位于顶层（即不在函数中）时，这才有效。

Answer 5

这就是我所做的：

def re_match_cond (match_ref, regex, text):
    match = regex.match (text)
    del match_ref[:]
    match_ref.append (match)
    return match

if __name__ == '__main__':
    match_ref = []
    if re_match_cond (match_ref, regex_1, text):
        match = match_ref[0]
        ### ...
    elif re_match_cond (match_ref, regex_2, text):
        match = match_ref[0]
        ### ...
    elif re_match_cond (match_ref, regex_3, text):
        match = match_ref[0]
        ### ...
    else:
        ### no match
        ### ...

也就是说，我将一个列表传递给函数以模拟按引用传递。

Answer 6

我认为这不是小事。 如果我经常编写这样的代码，我不想在代码中添加多余的条件。

这有点奇怪，但你可以使用迭代器来做到这一点：

import re

def rematch(pattern, inp):
    matcher = re.compile(pattern)
    matches = matcher.match(inp)
    if matches:
        yield matches

if __name__ == '__main__':
    for m in rematch("(\d+)g", "123g"):
        print(m.group(1))

奇怪的是它使用迭代器来处理不迭代的东西——它更接近条件，乍一看它可能看起来会产生每场比赛有多个结果。

上下文管理器不能导致其托管函数被完全跳过，这看起来确实很奇怪； 虽然这不是“with”的明确用例之一，但它似乎是一个自然的扩展。

Answer 7

从 Python 3.8 开始，并引入赋值表达式 (PEP 572 )（:= 运算符），我们现在可以捕获条件值 re.match(r'(\d+)g', '123g')变量 match 以便检查它是否不是 None，然后在条件体内重新使用它：

>>> if match := re.match(r'(\d+)g', '123g'):
...   print(match.group(1))
... 
123
>>> if match := re.match(r'(\d+)g', 'dddf'):
...   print(match.group(1))
...
>>>

Answer 8

另一种不错的语法是这样的：

header = re.compile('(.*?) = (.*?)
)
footer = re.compile('(.*?): (.*?)
)

if header.match(line) as m:
    key, value = m.group(1,2)
elif footer.match(line) as m
    key, value = m.group(1,2)
else:
    key, value = None, None

Answer 9

我有另一种方法来做到这一点，基于 Glen Maynard 的解决方案：

for match in [m for m in [re.match(pattern,key)] if m]:
    print "It matched: %s" % match

与 Glen 的解决方案类似，这会迭代 0（如果不匹配）或 1（如果匹配）次。

不需要潜艇，但结果不太整洁。

Answer 10

如果您在一个地方做了很多这样的事情，这里有一个替代答案：

import re
class Matcher(object):
    def __init__(self):
        self.matches = None
    def set(self, matches):
        self.matches = matches
    def __getattr__(self, name):
        return getattr(self.matches, name)

class re2(object):
    def __init__(self, expr):
        self.re = re.compile(expr)

    def match(self, matcher, s):
        matches = self.re.match(s)
        matcher.set(matches)
        return matches

pattern = re2("(\d+)g")
m = Matcher()
if pattern.match(m, "123g"):
    print(m.group(1))
if not pattern.match(m, "x123g"):
    print "no match"

您可以使用与 re 相同的线程安全性编译一次正则表达式，为整个函数创建一个可重用的 Matcher 对象，然后您可以非常方便地使用它简洁地。 这还有一个好处是您可以通过明显的方式反转它——要使用迭代器来做到这一点，您需要传递一个标志来告诉它反转其结果。

不过，如果每个函数只进行一次匹配，那么这并没有多大帮助； 您不想将 Matcher 对象保留在比这更广泛的上下文中； 它会导致与 Blixt 的解决方案相同的问题。