<p>What is the difference between the <code>search()</code> and <code>match()</code> functions in the Python <code>re</code> module?</p>
<p>I've read the <a href="https://docs.python.org/2/library/re.html?highlight=matching%20searching#search-vs-match" rel="nofollow noreferrer">Python 2 documentation</a> (<a href="https://docs.python.org/3/library/re.html#search-vs-match" rel="nofollow noreferrer">Python 3 documentation</a>), 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.</p>

```
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 the
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
```
search()
```
instead.
```
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
```
search
```
.
The documentation has a
specific section for
```
match
```
vs.
```
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).
Note that
```
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 see some example code:
```
```
# example code:
string_with_newlines = """something
someotherthing"""

import re

print re.match('some', string_with_newlines) # matches
print re.match('someother', 
               string_with_newlines) # won't match
print re.match('^someother', string_with_newlines, 
               re.MULTILINE) # also won't match
print re.search('someother', 
                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
print m.search(string_with_newlines, 
               re.MULTILINE) # also matches
```
```