blocks|key|1642220|text|我不确定你到底在做什么，但试着使用一个单独的组，里面有很多OR子句...所以(这个)%7C(那个)变成了(这个%7C那个)。您可以通过传递一个函数来对结果做一些聪明的事情，该函数对匹配的特定单词执行某些操作：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1642221|+newContents,+num+=+cregex.subn(lambda+m:+replacements[m.string[m.start():m.end()]],+contents)|code-block|syntax|javascript|1642222|如果你真的需要这么多组，你可能不得不分阶段去做……一次通过十几个大的组，然后在这些组中的每个组中进行另一次传递，以获得您想要的所有细节。|1642223|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

I'm not sure what you're doing exactly, but try using a single group, with a lot of OR clauses inside... so (this)|(that) becomes (this|that). You can do clever things with the results by passing a function that does something with the particular word that is matched:

<pre><code> newContents, num = cregex.subn(lambda m: replacements[m.string[m.start():m.end()]], contents)
</code></pre>

If you really need so many groups, you'll probably have to do it in stages... one pass for a dozen big groups, then another pass inside each of those groups for all the details you want.

blocks|key|1427204|text|这是有限制的，因为它将占用太多的内存来有效地存储完整的状态机。我要说的是，如果你的re中有超过100个组，那么无论是re本身还是你使用它们的方式都有问题。也许您需要拆分输入，并在较小的块或其他工作。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1427205|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

There is a limit because it would take too much memory to store the complete state machine efficiently. I'd say that if you have more than 100 groups in your re, something is wrong either in the re itself or in the way you are using them. Maybe you need to split the input and work on smaller chunks or something.

blocks|key|1427567|text|我发现最简单的方法就是|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1427568|import+regex+as+re|code-block|syntax|javascript|1427569|而不是|1427570|import+re|1427571|我相信正则表达式的默认_MAXCACHE是500而不是100。这是我发现regex是比re更好的模块的众多原因之一。|1427572|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

I found the easiest way was to

<pre><code>import regex as re
</code></pre>

instead of 

<pre><code>import re
</code></pre>

The default _MAXCACHE for regex is 500 instead of 100 I believe. This is one of the many reasons I find regex to be a better module than re.

blocks|key|1427510|text|如果我没记错的话，“新的”regex模块(目前是第三方的，但打算最终替换stdlib中的re模块)没有这个限制，所以您可以试一下。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1427511|entityMap|0|LINK|mutability|MUTABLE|url|http://pypi.python.org/pypi/regex/^0|D|5|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]]]]

If I'm not mistaken, the "new" <a href="http://pypi.python.org/pypi/regex/" rel="noreferrer">regex</a> module (currently third-party, but intended to eventually replace the re module in the stdlib) does not have this limit, so you might give that a try.

blocks|key|1427715|text|我怀疑您是否真的需要使用next命令处理100个命名组，或者在regexp替换命令中使用它。这是非常不切实际的。如果你只需要分组来表达regexp中的丰富条件，你可以使用非分组分组。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1427716|(?:word1%7Cword2)(?:word3%7Cword4)|code-block|syntax|javascript|1427717|等等。包括嵌套组在内的复杂场景是可能的。对非分组的分组没有限制。|1427718|entityMap^0|V|6|1V|6|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]|$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|T|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|U|8|@]|D|@]|E|$]]|$1|M|3|-4|5|6|7|V|8|@]|D|@]|E|$]]]|N|$]]

I doubt you really need to process 100 named groups by next commands or use it in <code>regexp</code> replacement command. It would be quite impractical. If you just need groups to express the rich conditions in <code>regexp</code> you can use non-grouping group. 

<pre><code>(?:word1|word2)(?:word3|word4)
</code></pre>

etc. Complex scenarios including nesting groups are possible.
There is no limit for non-grouping groups.

blocks|key|1642165|text|首先，正如其他人所说，除了使用100个组之外，可能还有更好的替代方案。re.findall方法可能是一个有用的起点。如果您确实需要100个以上的组，我看到的唯一解决方法是修改核心Python代码。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1642166|在[python-install-dir]/lib/sre_compile.py中，只需通过删除以下行来修改compile()函数：|1642167|#+in+lib/sre_compile.py
if+pattern.groups+>+100:
++++raise+AssertionError(
++++++++"sorry,+but+this+version+only+supports+100+named+groups"
++++++++)|code-block|syntax|javascript|1642168|对于稍微灵活一点的版本，只需在sre_compile模块的顶部定义一个常量，并将上一行与该常量进行比较，而不是100。|1642169|有趣的是，在(Python2.5)源代码中有一条注释指出，计划在未来的版本中删除100组的限制。|1642170|entityMap^0|Z|A|0|1|13|1I|9|0|0|F|B|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@$9|T|A|U|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|V|8|@$9|W|A|X|B|C]|$9|Y|A|Z|B|C]]|D|@]|E|$]]|$1|H|3|I|5|J|7|10|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|11|8|@$9|12|A|13|B|C]]|D|@]|E|$]]|$1|O|3|P|5|6|7|14|8|@]|D|@]|E|$]]|$1|Q|3|-4|5|6|7|15|8|@]|D|@]|E|$]]]|R|$]]

First, as others have said, there are probably good alternatives to using 100 groups. The <code>re.findall</code> method might be a useful place to start. If you really need more than 100 groups, the only workaround I see is to modify the core Python code. 

In <code>[python-install-dir]/lib/sre_compile.py</code> simply modify the <code>compile()</code> function by removing the following lines:

<pre><code># in lib/sre_compile.py
if pattern.groups &gt; 100:
 raise AssertionError(
 "sorry, but this version only supports 100 named groups"
 )
</code></pre>

For a slightly more flexible version, just define a constant at the top of the <code>sre_compile</code> module, and have the above line compare to that constant instead of 100. 

Funnily enough, in the (Python 2.5) source there is a comment indicating that the 100 group limit is scheduled to be removed in future versions.

blocks|key|1642656|text|我发现Python3没有这个限制，而在最新的2.7版本中运行的相同代码显示了这个错误。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1642657|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

I've found that Python 3 doesn't have this limitation, whereas the same code ran in latest 2.7 displays this error.

blocks|key|1642509|text|当我遇到这个的时候，我有一个非常复杂的模式，它实际上是由一堆由OR连接的高级模式组成的，就像这样：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1642510|pattern_string+=+u"pattern1%7C"+\
++++u"pattern2%7C"+\
++++u"patternN"
pattern+=+re.compile(pattern_string,+re.UNICODE)

for+match+in+pattern.finditer(string_to_search):
++++pass+#+Extract+data+from+the+groups+in+the+match.|code-block|syntax|javascript|1642511|作为一种变通方法，我将模式转换为列表，并按如下方式使用该列表：|1642512|pattern_strings+=+[
++++u"pattern1",
++++u"pattern2",
++++u"patternN",
]
patterns+=+[re.compile(pattern_string,+re.UNICODE)+for+pattern_string+in+pattern_strings]

for+pattern+in+patterns:
++++for+match+in+pattern.finditer(string_to_search):
++++++++pass+#+Extract+data+from+the+groups+in+the+match.
++++string_to_search+=+pattern.sub(u"",+string_to_search)|1642513|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|$]]

When I run into this I had a really complex pattern that was actually composed of a bunch of high-level patterns joined by ORs, like this:

<pre><code>pattern_string = u"pattern1|" \
 u"pattern2|" \
 u"patternN"
pattern = re.compile(pattern_string, re.UNICODE)

for match in pattern.finditer(string_to_search):
 pass # Extract data from the groups in the match.
</code></pre>

As a workaround, I turned the pattern into a list and I used that list as follows:

<pre><code>pattern_strings = [
 u"pattern1",
 u"pattern2",
 u"patternN",
]
patterns = [re.compile(pattern_string, re.UNICODE) for pattern_string in pattern_strings]

for pattern in patterns:
 for match in pattern.finditer(string_to_search):
 pass # Extract data from the groups in the match.
 string_to_search = pattern.sub(u"", string_to_search)
</code></pre>

blocks|key|1642113|text|我想说的是，你可以通过使用非分组括号来减少分组的数量，但无论你在做什么，似乎你都想要所有这些分组。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1642114|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

I would say you could reduce the number of groups by using non-grouping parentheses, but whatever it is that you're doing seems like you want all these groupings.

blocks|key|1642266|text|在我的例子中，我有一个包含n个单词的字典，并希望创建一个匹配所有单词的正则表达式。例如:如果我的字典是|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1642267|hello
goodbye|code-block|syntax|javascript|1642268|我的正则表达式是：(%5E%7C\s)hello($%7C\s)%7C(%5E%7C\s)goodbye($%7C\s)+...这是唯一的方法，并且在小字典上工作得很好，但是当你有超过50个单词时，那么……|offset|length|style|CODE|1642269|entityMap^0|0|0|9|11|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@$I|R|J|S|K|L]]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

in my case, i have a dictionary of n words and want to create a single regex that matches all of them.. ie: if my dictionary is

<pre><code>hello
goodbye
</code></pre>

my regex would be: <code>(^|\s)hello($|\s)|(^|\s)goodbye($|\s)</code> ... it's the only way to do it, and works fine on small dictionaries, but when you have more tan 50 words, well...

blocks|key|1642399|text|解决这个错误非常容易:打开re类，您将看到这个常量_MAXCACHE+=+100。例如，将该值更改为1000，然后执行一个测试。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1642400|entityMap^0|D|2|P|F|1E|4|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]|$9|K|A|L|B|C]|$9|M|A|N|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|O|8|@]|D|@]|E|$]]]|G|$]]

It's very ease to resolve this error:
Open the <code>re</code> class and you'll see this constant <code>_MAXCACHE = 100</code>.
Change the value to <code>1000</code>, for example, and do a test.

Is there any way to beat the 100-group limit for regular expressions in Python? Also, could someone explain why there is a limit.

Python regular expressions with more than 100 groups?

Python

有没有办法突破Python中正则表达式100组的限制？另外，有人能解释一下为什么会有限制吗？

问拥有超过100个组的Python正则表达式？
EN

回答 11

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问拥有超过100个组的Python正则表达式？EN

回答 11

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问拥有超过100个组的Python正则表达式？
EN