Question

我知道有不同的方法可以做到这一点，但我只是想知道为什么我的正则表达式不起作用。这实际上并不是我需要做的事情，我只是想看看我是否可以用正则表达式做到这一点，而且我不知道为什么我的代码不起作用。

给定一个字符串S，我想找到所有包含符合某些规则的子序列Q的非重叠子字符串。现在，让我们假设我正在搜索子序列"abc"。我希望匹配包含'a'的S的子字符串，然后在'b'处跟随'c'，然后'a'跟随'a'之后'a'的限制'b' {，'b'后面没有regex = re.compile(r'a[^a]*?b[^ab]*?c') match = re.finditer(regex, string) for m in match: print m.group(0)或a[^a]*?b。我正在使用的正则表达式如下（在python中）：

'a'

对我来说，这会分解，如下所示：

'a'：'b'跟随最小的＃字符＃不包括[^ab]*?c并以'a'结尾 'b'：不包括'c'或S = "aqwertybwertcaabcc"且以"aqwertybwertc"

结尾的最小字符数

所以把这一切放在一起，我假设我会匹配S的非重叠子串，这些子串包含符合我的排除规则的子序列“abc”。

此可以正常使用，例如：

"abc"，它为我提供S = "abbc"和"abbc"，

但失败适用于{{1}}，因为它与{{1}}匹配。

Answer 1

假设您真正想要的是，子序列Q在第一个a和第一个a之间不包含b，而没有a或{{1在第一个b之后的第一个b和第一个c之间，正确的正则表达式是：

您当前正在使用的正则表达式将尽一切可能在字符串上取得成功，包括在第一个r'a[^ab]*b[^abc]*c'之后将文字b与b匹配，这是为什么b匹配。只有在第一个字符类中明确排除"abbc"才能避免这种情况，b只能匹配b之后的第一个b。

Answer 2

如果你看一下逆类，它会有所帮助在所有情况下abc都是微不足道的解决方案并且，在这种情况下，非贪婪可能不适用，因为
在示例逆类中使用固定的字符集。

 #  Type 1 :
 #  ( b or c can be between A,B )
 #  ( a or b can be between B,C )
 # ------------------------------
 a                    #  'a'              
 [b-z]*?              #  [^a]
 b                    #  'b'
 [abd-z]*?            #  [^c]
 c                    #  'c'


 #  Type 2, yours :
 #  ( b or c can be between A,B )
 #  ( c can be between B,C )
 # ------------------------------
 a                    #  'a'              
 [b-z]*?              #  [^a]
 b                    #  'b'
 [c-z]*?              #  [^ab]
 c                    #  'c'


 #  Type 3 :
 #  ( c can be between A,B )
 # ------------------------------
 a                    #  'a'              
 [c-z]*?              #  [^ab]
 b                    #  'b'
 [d-z]*?              #  [^abc]
 c                    #  'c'


 #  Type 4 :
 #  ( distinct A,B,C ) :
 # ------------------------------
 a                    #  'a'              
 [d-z]*?              #  [^abc]
 b                    #  'b'
 [d-z]*?              #  [^abc]
 c                    #  'c'

试图找到包含特定子序列的非重叠子串

2 个答案: