What is the difference between the
match() functions in the Python
I've read the documentation (current documentation), but I never seem to remember it. I keep having to look it up and re-learn it. I'm hoping that someone will answer it clearly with examples so that (perhaps) it will stick in my head. Or at least I'll have a better place to return with my question and it will take less time to re-learn it.
re.match is anchored at the beginning of the string. That has nothing to do with newlines, so it is not the same as using
^ in the pattern.
As re.match documentation says:
If zero or more characters at the beginning of string match the regular expression pattern, return a corresponding
MatchObject instance. Return
None if the string does not match the pattern; note that this is different from a zero-length match.
Note: If you want to locate a match anywhere in string, use
re.search searches the entire string, as the documentation says:
Scan through string looking for a location where the regular expression pattern produces a match, and return a corresponding
MatchObject instance. Return
None if no position in the string matches the pattern; note that this is different from finding a zero-length match at some point in the string.
So if you need to match at the beginning of the string, or to match the entire string use
match. It is faster. Otherwise use
The documentation has a specific section for
search that also covers multiline strings:
Python offers two different primitive operations based on regular expressions:
match checks for a match only at the beginning of the string, while
search checks for a match anywhere in the string (this is what Perl does by default).
match may differ from
search even when using a regular expression beginning with
'^' matches only at the start of the string, or in
MULTILINE mode also immediately following a newline. The “
match” operation succeeds only if the pattern matches at the start of the string regardless of mode, or at the starting position given by the optional
pos argument regardless of whether a newline precedes it.
Now, enough talk. Time to some example code:
# example code:
string_with_newlines = """something
print re.match('some', string_with_newlines) # matches
string_with_newlines) # won't match
print re.match('^someother', string_with_newlines,
re.MULTILINE) # also won't match
string_with_newlines) # finds something
print re.search('^someother', string_with_newlines,
re.MULTILINE) # also finds something
m = re.compile('thing$', re.MULTILINE)
print m.match(string_with_newlines) # no match
print m.match(string_with_newlines, pos=4) # matches
re.MULTILINE) # also matches
re.search searches for the pattern throughout the string, whereas
re.match does not search the pattern; if it does not, it has no other choice than to match it at start of the string.
search ⇒ find something anywhere in the string and return a match object.
match ⇒ find something at the beginning of the string and return a match object.
re.match attempts to match a pattern at the beginning of the string. re.search attempts to match the pattern throughout the string until it finds a match.
you can refer the below example to understand the working of re.match and re.search
a = "123abc"
t = re.match("[a-z]+",a)
t = re.search("[a-z]+",a)
re.match will return none, but re.search will return abc.
Have you had a look at the documentation?
Python offers two different primitive operations based on regular expressions: match checks for a match only at the beginning of the string, while search checks for a match anywhere in the string (this is what Perl does by default).