是否可以使用 AND 运算符之类的东西编写 Python 正则表达式？

Question

我找不到一种将多个正则表达式写入一个中的好方法，以便针对所有子正则表达式检查输入字符串，如下所示：

def match(input_str: str, regexp: str) -> bool:
    ...

print(match('abaaca', '.*aba.*<AND>.*aca.*'))  # True
print(match('abaca', '.*aba.*<AND>.*aca.*'))  # True, it doesn't matter that one letter a is shared
print(match('abac', '.*aba.*<AND>.*aca.*'). # False

有什么办法比解析正则表达式看看里面有没有<AND>，把字符串分成几个子正则表达式循环匹配？

UPD：需要明确的是，我正在寻找一种将其用作全功能运算符的方法，例如 ((a<AND>b)|(c<AND>d))<AND>e 将匹配所有字符串 abe、bae、cde 和dce。不仅是一个<AND>，而是几个，夹杂着括号。

Answer 1

正则表达式解决方案 使用正向预测组 (?=<sub>) 防止字符被消耗

import re

def match(input_str: str, regexp: str) -> bool:
    return re.search("".join([f"(?={sub})" for sub in re.split('<AND>', regexp)]), input_str) != None

print(match('abaaca', '.*aba.*<AND>.*aca.*'))  # True
print(match('abaca', '.*aba.*<AND>.*aca.*'))  # True, it doesn't matter that one letter a is shared
print(match('abac', '.*aba.*<AND>.*aca.*')) # False

=>

True
True
False

oneliner 相当于

def match(input_str: str, regexp: str):
    subs = re.split('<AND>', regexp)             # getting the sub patterns

    # next 3 lines create a pattern from the sub patterns
    pattern = ""
    for sub in subs:
        pattern = pattern + "(?=" + sub +  ")"   # positive lookahead syntax

    matches = re.search(pattern, input_str)
    return matches != None

对于示例模式'.*aba.*<AND>.*aca.*'，修改后的模式是(?=.*aba.*)(?=.*aca.*)

Answer 2

您还可以实现一个函数来检查所有模式是否与字符串匹配

import re

def matchall(patterns, string):
    return all([re.search(pattern, string) for pattern in patterns])

print(matchall([".*aba.*", ".*aca.*"], "abaaca"))  # True

Answer 3

共享一个字母a并不重要

不，你不能只用一个正则表达式来做到这一点。 From the documentation for match():

如果字符串开头的零个或多个字符与正则表达式模式匹配，则返回相应的匹配对象。

换句话说，整个正则表达式必须匹配字符串的开头。即使您更改为re.search()，您仍然必须匹配输入字符串中某处的整个正则表达式。 re.findall() 会搜索不重叠的匹配项。

Answer 4

基本上，正则表达式检查aba.*aca 或aca.*aba 的字符串。向后看是必要的，因为可能有一个 a 是两个子模式的一部分

import re

regex = r"aba.*(?<=a)ca|aca.*(?<=a)ba"
for s in ['abaaca', 'abaca', 'abac', 'aaacacabbaba', 'abababaca', 'abbbacaaaba']:
    print(s, '=>', bool(re.search(regex, s)))

输出：

abaaca => True
abaca => True
abac => False
aaacacabbaba => True
abababaca => True
abbbacaaaba => True

Answer 5

在 Artyom Vancyan answer 的基础上，我将遍历已编译的正则表达式列表，因为如果多次调用该函数，它将为您带来巨大的性能提升。

import re
expressions = [re.compile(r'abaaca'), re.compile(r'abaca'), re.compile(r'abac')]
def match_expressions(expressions, string_to_match):
    return all([expression.search(string_to_match) for expression in expressions])

Answer 6

import re


def match(input_str: str, regexp: str) -> bool:
    pattern = "".join(
        [f"(?={condition})" for condition in regexp.split("<AND>")]
    )

    return bool(re.findall(pattern, input_str))

print(match("abaaca", ".*aba.*<AND>.*aca.*"))  # True
print(match("abaca", ".*aba.*<AND>.*aca.*"))  # True, it doesn't matter that one letter a is shared
print(match("abac", ".*aba.*<AND>.*aca.*"))  # False

Answer 7

以下模式几乎匹配所有。

# Regex If order is important, i.e. should start with aba
pattern = r'.*ab(a.*a|a)ca.*' 
# Regex If order is not important, i.e. It can start with aba | aca
pattern = r'.*a(b(a.*a|a)c|c(a.*a|a)b)a.*'
# OUTPUTS
#False inputs
string = ['abac','aba_ca','acab','_ab_ca_','acab','aca ba','_ababa_test_aba_']
print(re.search(pattern, string[0])) # O/P False
# True inputs
string = ["abaca",'acaba','aca_test_aba','_aba_test_aca_','acaaba','abaaca']
print(re.search(pattern, string[0])) # O/P True

Answer 8

不，python 正则表达式语法中没有这样的运算符。在这种情况下，您可以使用类似

.*ab(a.*)ca.*