为什么re.findall（）找到比re.sub（）更多的匹配？

Question

Consider the following:

>>> import re
>>> a = "first:second"
>>> re.findall("[^:]*", a)
['first', '', 'second', '']
>>> re.sub("[^:]*", r"(\g<0>)", a)
'(first):(second)'

re.sub() 's behavior makes more sense initially, but I can also understand re.findall() 's behavior. After all, you can match an empty string between first and : that consists only of non-colon characters (exactly zero of them), but why isn't re.sub() behaving the same way?

Shouldn't the result of the last command be (first)():(second)() ?

Answer 1

You use the * which allows empty matches:

'first'   -> matched
':'       -> not in the character class but, as the pattern can be empty due 
             to the *, an empty string is matched -->''
'second'  -> matched
'$'       -> can contain an empty string before,
             an empty string is matched -->''

Quoting the documentation for re.findall() :

Empty matches are included in the result unless they touch the beginning of another match.

The reason you don't see empty matches in sub results is explained in the documentation for re.sub() :

Empty matches for the pattern are replaced only when not adjacent to a previous match.

Try this:

re.sub('(?:Choucroute garnie)*', '#', 'ornithorynque') 

And now this:

print re.sub('(?:nithorynque)*', '#', 'ornithorynque')

There is no consecutive #

Answer 2

The algorithms for handling empty matches are different, for some reason.

In the case of findall , it works like (an optimized version of) this: for every possible start index 0 <= i <= len(a), if the string matches at i, then append the match; and avoid overlapping results by using this rule: if there is a match of length m at i, don't look for the next match before i+m. The reason your example returns ['first', '', 'second', ''] is that the empty matches are found immediately after first and second , but not after the colon --- because looking for a match starting from that position returns the full string second .

In the case of sub , the difference is, as you noticed, that it explicitly ignores matches of length 0 that occurs immediately after another match. While I see why this might help avoid unexpected behavior of sub , I'm unsure why there is this difference (eg why wouldn't findall use the same rule).

Answer 3

import re
a = "first:second:three"
print re.findall("[^:]*", a)

returns all substring that match pattern, here, it gives

>>> 
['first', '', 'second', '', 'three', '']

sub() is for substitution, and will substitute the left-most non-overlapping occurrences of pattern with your substitute. ex

import re
a = "first:second:three"
print re.sub("[^:]*", r"smile", a)

gives

>>> 
smile:smile:smile

You can command the number of occurrences to be replaced with the 4th arg, count: