blocks|key|2418482|text|不是的。Perl返回最长的、最左边的匹配，同时遵守非贪婪的量词。恐怕你得循环一遍。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2418483|编辑:是的，我意识到我在上面提到了Perl，但我相信Python也是如此。|2418484|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

No. Perl returns the longest, leftmost match, while obeying your non-greedy quantifiers. You'll have to loop, I'm afraid.

Edit: Yes, I realize I said Perl above, but I believe it is true for Python.

blocks|key|1009146|text|正则表达式引擎从字符串的开头开始搜索，直到找到匹配项，然后退出。因此，如果它甚至在考虑较小的匹配之前就找到了匹配，您就无法强制它在同一运行中考虑稍后的匹配-您将不得不重新运行子字符串上的正则表达式。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1009147|设置全局标志并选择最短的匹配字符串不会有什么帮助，因为从示例中可以明显看出-较短的匹配可能是另一个匹配的子字符串(或部分包含在其中)。我相信你将不得不从(前一场比赛的1%2B索引)开始后续搜索，然后继续下去。|1009148|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

The regex engine starts searching from the beginning of the string till it finds a match and then exits. Thus if it finds a match before it even considers the smaller one, there is no way for you to force it to consider later matches in the same run - you will have to rerun the regex on substrings.

Setting the global flag and choosing the shortest matched string won't help as it is evident from your example - the shorter match might be a substring of another match (or partly included in it). I believe you will have to start subsequent searches from (1 + index of previous match) and go on like that.

blocks|key|1009167|text|我不认为这项任务可以通过一个正则表达式来完成。我没有证据证明是这样的，但有相当多的事情是不能用正则表达式完成的，我希望这个问题就是其中之一。this+blog+post中提供了一些有关正则表达式局限性的很好的示例。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1009168|entityMap|0|LINK|mutability|MUTABLE|url|http://blogs.msdn.com/jaredpar/archive/2008/10/15/regular-expression-limitations.aspx^0|1Y|E|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

I do not think that this task can be accomplished by a single regular expression. I have no proof that this is the case, but there are quite a lot of things that can't be done with regexes and I expected this problem to be one of them. Some good examples of the limitations of regexes are given in <a href="http://blogs.msdn.com/jaredpar/archive/2008/10/15/regular-expression-limitations.aspx" rel="nofollow noreferrer">this blog post</a>.

blocks|key|770764|text|这可能是一个有用的sexegers应用程序。正则表达式匹配偏向于最长、最左边的选择。使用非贪婪的量词，比如在.*?中绕过最长的部分，并颠倒输入和模式都可以绕过最左边的匹配语义。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|770765|考虑以下根据需要输出A%7CB%7CC的程序：|770766|#!+/usr/bin/env+python

import+re

string+=+"A%7CB%7CA%7CB%7CC%7CD%7CE%7CF%7CG"
my_pattern+=+'c.*?b.*?a'

my_regex+=+re.compile(my_pattern,+re.DOTALL%7Cre.IGNORECASE)
matches+=+my_regex.findall(string[::-1])

for+match+in+matches:
++++print+match[::-1]|code-block|syntax|javascript|770767|另一种方法是创建一个更严格的模式。假设你不想重复已经看到的字符：|770768|my_pattern+=+'a[%5Ea]*?b[%5Eab]*?c'|770769|您的示例是通用的和人为的，但如果我们对您正在使用的输入有更好的想法，我们就可以提供更好、更有帮助的建议。|770770|entityMap|0|LINK|mutability|MUTABLE|url|http://www.perlmonks.org/index.pl?node=sexeger^0|1I|3|9|8|0|0|A|5|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@$9|11|A|12|B|C]]|D|@$9|13|A|14|1|15]]|E|$]]|$1|F|3|G|5|6|7|16|8|@$9|17|A|18|B|C]]|D|@]|E|$]]|$1|H|3|I|5|J|7|19|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|1A|8|@]|D|@]|E|$]]|$1|O|3|P|5|J|7|1B|8|@]|D|@]|E|$K|L]]|$1|Q|3|R|5|6|7|1C|8|@]|D|@]|E|$]]|$1|S|3|-4|5|6|7|1D|8|@]|D|@]|E|$]]]|T|$U|$5|V|W|X|E|$Y|Z]]]]

This might be a useful application of <a href="http://www.perlmonks.org/index.pl?node=sexeger" rel="nofollow noreferrer">sexegers</a>. Regular-expression matching is biased toward the longest, leftmost choice. Using non-greedy quantifiers such as in <code>.*?</code> skirts the longest part, and reversing both the input and pattern can get around leftmost-matching semantics.

Consider the following program that outputs <code>A|B|C</code> as desired:

<pre><code>#! /usr/bin/env python

import re

string = "A|B|A|B|C|D|E|F|G"
my_pattern = 'c.*?b.*?a'

my_regex = re.compile(my_pattern, re.DOTALL|re.IGNORECASE)
matches = my_regex.findall(string[::-1])

for match in matches:
 print match[::-1]
</code></pre>

Another way is to make a stricter pattern. Say you don't want to allow repetitions of characters already seen:

<pre><code>my_pattern = 'a[^a]*?b[^ab]*?c'
</code></pre>

Your example is generic and contrived, but if we had a better idea of the inputs you're working with, we could offer better, more helpful suggestions.

blocks|key|2418617|text|您可以以这样的方式编写正则表达式，使其不能包含较小的匹配项。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2418618|对于您的正则表达式：|2418619|a.*?b.*?c|code-block|syntax|javascript|2418620|我认为你可以这样写：|2418621|a[%5Eab]*b[%5Ec]*c|2418622|要做到这一点很棘手，我没有看到任何更普遍或更明显的正确方法来做到这一点。(编辑-早些时候我建议了一个负面的先行断言，但我看不到一种方法来实现它。)|2418623|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|R|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|S|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|T|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|U|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|V|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

You might be able to write the regex in such a way that it can't contain smaller matches.

For your regex:

<pre><code>a.*?b.*?c
</code></pre>

I think you can write this:

<pre><code>a[^ab]*b[^c]*c
</code></pre>

It's tricky to get that correct, and I don't see any more general or more obviously correct way to do it. (Edit&mdash;earlier I suggested a negative lookahead assertion, but I don't see a way to make that work.)

blocks|key|1009298|text|一个寻找最短匹配的Python循环，通过暴力从左到右测试每个子字符串，选择最短的：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1009299|shortest+=+None
for+i+in+range(len(string)):
++++m+=+my_regex.match(string[i:])
++++if+m:+
++++++++mstr+=+m.group()
++++++++if+shortest+is+None+or+len(mstr)+<+len(shortest):
++++++++++++shortest+=+mstr

print+shortest|code-block|syntax|javascript|1009300|另一个循环，这次让re.findall做搜索所有可能的匹配的艰苦工作，然后从右到左对每个匹配进行暴力测试，寻找更短的子字符串：|1009301|#+find+all+matches+using+findall
matches+=+my_regex.findall(string)

#+for+each+match,+try+to+match+right-hand+substrings
shortest+=+None
for+m+in+matches:
++++for+i+in+range(-1,-len(m),-1):
++++++++mstr+=+m[i:]++++++++
++++++++if+my_regex.match(mstr):
++++++++++++break
++++else:
++++++++mstr+=+m

++++if+shortest+is+None+or+len(mstr)+<+len(shortest):
++++++++shortest+=+mstr

print+shortest|1009302|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

A Python loop to look for the shortest match, by brute force testing each substring from left to right, picking the shortest:

<pre><code>shortest = None
for i in range(len(string)):
 m = my_regex.match(string[i:])
 if m: 
 mstr = m.group()
 if shortest is None or len(mstr) &lt; len(shortest):
 shortest = mstr

print shortest
</code></pre>

Another loop, this time letting re.findall do the hard work of searching for all possible matches, then brute force testing each match right-to-left looking for a shorter substring:

<pre><code># find all matches using findall
matches = my_regex.findall(string)

# for each match, try to match right-hand substrings
shortest = None
for m in matches:
 for i in range(-1,-len(m),-1):
 mstr = m[i:] 
 if my_regex.match(mstr):
 break
 else:
 mstr = m

 if shortest is None or len(mstr) &lt; len(shortest):
 shortest = mstr

print shortest
</code></pre>

blocks|key|770819|text|不，在Python正则表达式引擎中没有。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|770820|不过，我对自定义函数的理解是：|770821|import+re,+itertools

#+directly+from+itertools+recipes
def+pairwise(iterable):
++++"s+->+(s0,s1),+(s1,s2),+(s2,+s3),+..."
++++a,+b+=+itertools.tee(iterable)
++++for+elem+in+b:
++++++++break
++++return+itertools.izip(a,+b)

def+find_matches(rex,+text):
++++"Find+all+matches,+even+overlapping+ones"
++++matches=+list(rex.finditer(text))

++++#+first+produce+typical+matches
++++for+match+in+matches:
++++++++yield+match.group(0)

++++#+next,+run+it+for+any+patterns+included+in+matches
++++for+match1,+match2+in+pairwise(matches):
++++++++subtext=+text[match1.start()%2B1:match2.end()%2B1]
++++++++for+result+in+find_matches(rex,+subtext):
++++++++++++yield+result

++++#+also+test+the+last+match,+if+there+was+at+least+one
++++if+matches:
++++++++subtext=+text[matches[-1].start()%2B1:matches[-1].end()%2B1]
++++++++#+perhaps+the+previous+"matches[-1].end()%2B1"+can+be+omitted
++++++++for+result+in+find_matches(rex,+subtext):
++++++++++++yield+result

def+shortest_match(rex,+text):
++++"Find+the+shortest+match"
++++return+min(find_matches(rex,+text),+key=len)

if+__name__+==+"__main__":
++++pattern=+re.compile('a.*?b.*?c',+re.I)
++++searched_text=+"A%7CB%7CA%7CB%7CC%7CD%7CE%7CF%7CG"
++++print+(shortest_match(pattern,+searched_text))|code-block|syntax|javascript|770822|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

No, there isn't in the Python regular expression engine.

My take for a custom function, though:

<pre><code>import re, itertools

# directly from itertools recipes
def pairwise(iterable):
 "s -&gt; (s0,s1), (s1,s2), (s2, s3), ..."
 a, b = itertools.tee(iterable)
 for elem in b:
 break
 return itertools.izip(a, b)

def find_matches(rex, text):
 "Find all matches, even overlapping ones"
 matches= list(rex.finditer(text))

 # first produce typical matches
 for match in matches:
 yield match.group(0)

 # next, run it for any patterns included in matches
 for match1, match2 in pairwise(matches):
 subtext= text[match1.start()+1:match2.end()+1]
 for result in find_matches(rex, subtext):
 yield result

 # also test the last match, if there was at least one
 if matches:
 subtext= text[matches[-1].start()+1:matches[-1].end()+1]
 # perhaps the previous "matches[-1].end()+1" can be omitted
 for result in find_matches(rex, subtext):
 yield result

def shortest_match(rex, text):
 "Find the shortest match"
 return min(find_matches(rex, text), key=len)

if __name__ == "__main__":
 pattern= re.compile('a.*?b.*?c', re.I)
 searched_text= "A|B|A|B|C|D|E|F|G"
 print (shortest_match(pattern, searched_text))
</code></pre>

blocks|key|770837|text|另一个正则表达式解决方案；它只查找最后出现的.*a.*b.*c：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|770838|my_pattern+=+'a(?!.*a.*b.*c).*b[%5Ec]*c'|code-block|syntax|javascript|770839|a(?!.*a.*?b.*?c)确保在消除结果中的前'A‘字符串(如A%7CA%7CB%7CC或A%7CB%7CA%7CB%7CC或A%7CB%7CC%7CA%7CB%7CC+)后不存在'a.*?b.*?c'|offset|length|style|CODE|770840|b[%5Ec]*c确保结果中'B‘之后只有一个'C’字符串被消除，如A%7CB%7CC%7CB%7CC或A%7CB%7CC%7CC|770841|这样你就有了最小的匹配'a.*?b.*?c'|770842|entityMap^0|0|0|0|G|1X|B|0|0|7|0|B|B|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@$I|V|J|W|K|L]|$I|X|J|Y|K|L]]|9|@]|A|$]]|$1|M|3|N|5|6|7|Z|8|@$I|10|J|11|K|L]]|9|@]|A|$]]|$1|O|3|P|5|6|7|12|8|@$I|13|J|14|K|L]]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|15|8|@]|9|@]|A|$]]]|R|$]]

Another regex solution; it finds only the last occurence of .*a.*b.*c:

<pre><code>my_pattern = 'a(?!.*a.*b.*c).*b[^c]*c'
</code></pre>

<code>a(?!.*a.*?b.*?c)</code> ensures that there is no <code>'a.*?b.*?c'</code> after first 'A'
strings like A|A|B|C or A|B|A|B|C or A|B|C|A|B|C in results are eliminated

<code>b[^c]*c</code> ensures that after 'B' there is only one 'C'
strings like A|B|C|B|C or A|B|C|C in results are eliminated

So you have the smallest matching <code>'a.*?b.*?c'</code>

blocks|key|2418778|text|与这里的大多数其他答案相反，这可以在使用带有capturing+group的positive+lookahead+assertion的单个正则表达式中完成|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|2418779|>>>+my_pattern+=+'(?=(a.*?b.*?c))'
>>>+my_regex+=+re.compile(my_pattern,+re.DOTALL%7Cre.IGNORECASE)
>>>+matches+=+my_regex.findall(string)
>>>+print+min(matches,+key=len)
A%7CB%7CC|code-block|syntax|javascript|2418780|findall()将返回所有可能的匹配项，因此您需要min()来获取最短的匹配项。|style|CODE|2418781|它是如何工作的：|2418782|2418783|我们不匹配这个正则表达式中的任何文本，只匹配字符串中的位置(正则表达式引擎在尝试匹配时逐步执行)。|unordered-list-item|2418784|在每个位置，正则表达式引擎都会向前看，看看您的正则表达式在这个位置是否匹配。|2418785|如果是，则会被捕获组捕获。|2418786|如果不是，就不会。|2418787|在这两种情况下，正则表达式引擎都会前进一个字符，并重复这个过程，直到字符串结束。|2418788|由于先行断言不占用任何字符，因此将找到所有重叠的匹配项。|2418789|2418790|entityMap|0|LINK|mutability|MUTABLE|url|http://www.regular-expressions.info/brackets.html|1|http://www.regular-expressions.info/lookaround.html^0|M|F|0|12|S|1|0|0|0|9|Q|5|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|1D|8|@]|9|@$A|1E|B|1F|1|1G]|$A|1H|B|1I|1|1J]]|C|$]]|$1|D|3|E|5|F|7|1K|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|1L|8|@$A|1M|B|1N|K|L]|$A|1O|B|1P|K|L]]|9|@]|C|$]]|$1|M|3|N|5|6|7|1Q|8|@]|9|@]|C|$]]|$1|O|3|-4|5|6|7|1R|8|@]|9|@]|C|$]]|$1|P|3|Q|5|R|7|1S|8|@]|9|@]|C|$]]|$1|S|3|T|5|R|7|1T|8|@]|9|@]|C|$]]|$1|U|3|V|5|R|7|1U|8|@]|9|@]|C|$]]|$1|W|3|X|5|R|7|1V|8|@]|9|@]|C|$]]|$1|Y|3|Z|5|R|7|1W|8|@]|9|@]|C|$]]|$1|10|3|11|5|R|7|1X|8|@]|9|@]|C|$]]|$1|12|3|-4|5|6|7|1Y|8|@]|9|@]|C|$]]|$1|13|3|-4|5|6|7|1Z|8|@]|9|@]|C|$]]]|14|$15|$5|16|17|18|C|$19|1A]]|1B|$5|16|17|18|C|$19|1C]]]]

Contrary to most other answers here, this can be done in a single regex using a <a href="http://www.regular-expressions.info/lookaround.html" rel="noreferrer">positive lookahead assertion</a> with a <a href="http://www.regular-expressions.info/brackets.html" rel="noreferrer">capturing group</a>:

<pre><code>&gt;&gt;&gt; my_pattern = '(?=(a.*?b.*?c))'
&gt;&gt;&gt; my_regex = re.compile(my_pattern, re.DOTALL|re.IGNORECASE)
&gt;&gt;&gt; matches = my_regex.findall(string)
&gt;&gt;&gt; print min(matches, key=len)
A|B|C
</code></pre>

<code>findall()</code> will return all possible matches, so you need <code>min()</code> to get the shortest one.

How this works:

<ul>
<li>We're not matching any text in this regex, just positions in the string (which the regex engine steps through during a match attempt). </li>
<li>At each position, the regex engine looks ahead to see whether your regex would match at this position. </li>
<li>If so, it will be captured by the capturing group. </li>
<li>If not, it won't. </li>
<li>In either case, the regex engine then steps ahead one character and repeats the process until the end of the string. </li>
<li>Since the lookahead assertion doesn't consume any characters, all overlapping matches will be found.</li>
</ul>

I'm still relatively new to regex. I'm trying to find the shortest string of text that matches a particular pattern, but am having trouble if the shortest pattern is a substring of a larger match. For example:

<pre><code>import re
string = "A|B|A|B|C|D|E|F|G"
my_pattern = 'a.*?b.*?c'

my_regex = re.compile(my_pattern, re.DOTALL|re.IGNORECASE)
matches = my_regex.findall(string)

for match in matches:
 print match
</code></pre>

prints: 

<pre><code>A|B|A|B|C
</code></pre>

but I'd want it to return:

<pre><code>A|B|C
</code></pre>

Is there a way to do this without having to loop over each match to see if it contains a substring that matches?

How do I find the shortest overlapping match using regular expressions?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

对于regex来说，我还是个新手。我试图找到与特定模式匹配的最短文本字符串，但如果最短模式是较大匹配的子串，则会遇到问题。例如：import restring = "A|B|A|B|C|D|E|F|G"my_pattern = 'a.*?b.*?c'my_regex = re.compile(my_pattern, r...

问如何使用正则表达式找到最短的重叠匹配？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何使用正则表达式找到最短的重叠匹配？EN