re.search 和 re.match 有什么区别？

Question

Python re 模块中的 search() 和 match() 函数有什么区别？

我已阅读 Python 2 文档< /a> （Python 3 文档），但我似乎从来不记得它。

Answer 1

re.match 锚定在字符串的开头，而 re.search 则扫描整个字符串。 因此，在下面的示例中，x 和 y 匹配相同的内容。

x = re.match('pat', s)       # <--- already anchored at the beginning of string
y = re.search('\Apat', s)    # <--- match at the beginning

如果字符串不包含换行符，则 \A 和 ^ 本质上是相同的； 差异显示在多行字符串中。 在以下示例中，re.match 永远不会匹配第二行，而 re.search 可以使用正确的正则表达式（和标志）。

s = "1\n2"
re.match('2', s, re.M)       # no match
re.search('^2', s, re.M)     # match
re.search('\A2', s, re.M)    # no match  <--- mimics `re.match`

re 中还有一个函数 re.fullmatch() 会扫描整个字符串，因此它会同时锚定在字符串的开头和结尾。 因此，在下面的示例中，x、y 和 z 匹配相同的内容。

x = re.match('pat\Z', s)     # <--- already anchored at the beginning; must match end
y = re.search('\Apat\Z', s)  # <--- match at the beginning and end of string
z = re.fullmatch('pat', s)   # <--- already anchored at the beginning and end

---

基于 Jeyekomon 的答案（并使用他们的设置），使用 perfplot 库，我绘制了 timeit 测试的结果，该测试调查了：

• 如果re.search“模仿”re.match，他们如何比较？ （第一个图）
• 如果re.match“模仿”re.search，他们如何比较？ （第二个图）
• 如果将相同的模式传递给他们，他们如何比较？ （最后一个图）

请注意，最后一个模式不会产生相同的输出（因为 re.match 锚定在字符串的开头。）

第一个图显示 match 一样使用 search，>match 会更快。 第二个图支持@Jeyekomon的答案，并显示如果像search一样使用match，search会更快。 最后一张图显示，如果两者扫描相同的模式，则两者之间几乎没有什么区别。

---

用于生成性能图的代码。

import re
from random import choices
from string import ascii_lowercase
import matplotlib.pyplot as plt
from perfplot import plot

patterns = [
    [re.compile(r'\Aword'), re.compile(r'word')],
    [re.compile(r'word'), re.compile(r'(.*?)word')],
    [re.compile(r'word')]*2
]

fig, axs = plt.subplots(1, 3, figsize=(20,6), facecolor='white')
for i, (pat1, pat2) in enumerate(patterns):
    plt.sca(axs[i])
    perfplot.plot(
        setup=lambda n: [''.join(choices(ascii_lowercase, k=10)) for _ in range(n)],
        kernels=[lambda lst: [*map(pat1.search, lst)], lambda lst: [*map(pat2.match, lst)]],
        labels= [f"re.search(r'{pat1.pattern}', w)", f"re.match(r'{pat2.pattern}', w)"],
        n_range=[2**k for k in range(24)],
        xlabel='Length of list',
        equality_check=None
    )
fig.suptitle('re.match vs re.search')
fig.tight_layout();

Answer 2

快速回答

re.search('test', ' test')      # returns a Truthy match object (because the search starts from any index) 

re.match('test', ' test')       # returns None (because the search start from 0 index)
re.match('test', 'test')        # returns a Truthy match object (match at 0 index)

Answer 3

re.match 尝试匹配字符串开头的模式。 re.search 尝试整个字符串匹配模式，直到找到匹配项。

Answer 4

更短：

• search 扫描整个字符串。

• match 仅扫描字符串的开头。

以下 Ex 说：

>>> a = "123abc"
>>> re.match("[a-z]+",a)
None
>>> re.search("[a-z]+",a)
abc

Answer 5

您可以参考下面的示例来了解 re.match 的工作原理，并且 re.search

a = "123abc"
t = re.match("[a-z]+",a)
t = re.search("[a-z]+",a)

re.match 将返回 none，但是 re.search 将返回 abc。

Answer 6

区别在于，re.match() 会误导任何习惯使用 Perl、grep 或 sed 的人正则表达式匹配，而 re.search() 则不然。 :-)

更清醒的是，正如 John D. Cook 所说，re.match()“表现得好像每个模式都在前面添加了 ^ ”。 换句话说，re.match('pattern') 等于re.search('^pattern')。 因此它锚定了图案的左侧。 但它也不锚定模式的右侧：仍然需要终止$。

坦率地说，鉴于上述情况，我认为应该弃用 re.match() 。 我很想知道应该保留它的原因。

Answer 7

re.search 在整个字符串中搜索模式，而 re.match 不搜索 模式； 如果不匹配，则除了在字符串开头匹配之外别无选择。

Answer 8

匹配比搜索快得多，因此您可以使用 regex.match((.*?)word(.*?)) 代替 regex.search("word") 并在工作时获得大量性能拥有数百万个样本。

这条评论来自 @ivan_bilan 在上面接受的答案下 让我思考这样的黑客是否真的能加速任何事情，所以让我们看看您将真正获得多少性能。

我准备了以下测试套件：

import random
import re
import string
import time

LENGTH = 10
LIST_SIZE = 1000000

def generate_word():
    word = [random.choice(string.ascii_lowercase) for _ in range(LENGTH)]
    word = ''.join(word)
    return word

wordlist = [generate_word() for _ in range(LIST_SIZE)]

start = time.time()
[re.search('python', word) for word in wordlist]
print('search:', time.time() - start)

start = time.time()
[re.match('(.*?)python(.*?)', word) for word in wordlist]
print('match:', time.time() - start)

我进行了 10 次测量（1M、2M、...、10M 个单词），得到了以下图：

如您所见，搜索对于模式 'python' 比匹配模式 '(.*?)python(.*?)' 更快。

Python 很聪明。 避免试图变得更聪明。

Answer 9

search ⇒ 在字符串中的任意位置查找内容并返回匹配对象。

match ⇒ 在字符串的开头查找某些内容并返回一个匹配对象。

Answer 10

re.match 锚定在字符串的开头。 这与换行符无关，因此它与在模式中使用 ^ 不同。

正如 re.match 文档 所说：

如果零个或多个字符
字符串开头 匹配正则表达式模式，返回
相应的 MatchObject 实例。
如果字符串不存在，则返回 None
匹配图案； 请注意，这是
与零长度匹配不同。

注意：如果您想查找匹配项
字符串中的任何位置，使用 search()
相反。

re.search 搜索整个字符串，如 文档说：

扫描字符串寻找
正则表达式所在的位置
模式产生匹配，并返回
相应的 MatchObject 实例。
如果没有位置则返回 None
字符串与模式匹配； 注意
这与寻找一个不同
中某个点的零长度匹配
字符串。

因此，如果您需要在字符串的开头匹配，或者匹配整个字符串，请使用 match。 它更快。 否则使用搜索。

该文档有一个 match 的特定部分与也涵盖多行字符串的 search 相比：

Python 提供了两种不同的原语
基于常规的操作
表达式：match 检查匹配
仅在字符串的开头，
search 检查匹配项
字符串中的任意位置（这就是
Perl 默认情况下是这样做的）。

请注意，匹配可能与搜索不同
即使使用正则表达式
以 '^' 开头：仅匹配 '^'
在字符串的开头，或者在
MULTILINE 模式也立即
跟随换行符。 “匹配”
仅当模式成功时，操作才会成功
匹配字符串的开头
无论模式如何，或在开始时
由可选的 pos 给出的位置
论点，无论是否
换行符位于其前面。

现在，说得够多了。 是时候看一些示例代码了：

# 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