Was ist der Unterschied zwischen re.search und re.match?

Was ist der Unterschied zwischen den search() und match() Funktionen in der Python re - Modul?

Ich habe gelesen, die Dokumentation (aktuelle Dokumentation), aber ich habe nie scheinen, Sie zu erinnern. Ich muss immer wieder nachlesen und neu zu lernen. Ich bin der Hoffnung, dass jemand beantworten übersichtlich, mit Beispielen, so dass (vielleicht) wird es bleiben in meinem Kopf. Oder zumindest werde ich einen besseren Ort, um zurückzukehren mit meiner Frage und es wird weniger Zeit, um neu zu lernen.

InformationsquelleAutor Daryl Spitzer | 2008-10-08

429

re.match verankert wird am Anfang der Zeichenfolge. Das hat nichts zu tun mit newlines, so ist es nicht das gleiche wie mit ^ im Muster.

Als re.match-Dokumentation sagt:

Wenn null oder mehr Zeichen am
Anfang der Zeichenfolge entsprechen dem Muster des regulären Ausdrucks zurückgeben
entsprechende MatchObject Instanz.
Zurück None wenn der string nicht
die dem Muster entsprechen; zu beachten ist, dass dies
unterscheidet sich von einer null-Länge entsprechen.

Hinweis: Wenn Sie möchten, suchen Sie ein Spiel
überall in der Zeichenfolge, verwenden Sie search()
statt.

re.search durchsucht den gesamten string, wie die Dokumentation sagt:

Durchsuchen, string der Suche nach einem
Standort, an denen der reguläre Ausdruck
das Muster erzeugt einen match, und geben Sie einen
entsprechende MatchObject Instanz.
Zurück None wenn keine position in der
string dem Muster entspricht; beachten Sie, dass
dies unterscheidet sich von der Suche nach einem
mit der Länge null Spiel an einem gewissen Punkt in der
string.

Also, wenn Sie brauchen, um übereinstimmung am Anfang des Strings, oder entsprechen die gesamte Zeichenfolge verwenden match. Es ist schneller. Ansonsten verwenden Sie search.

Die Dokumentation hat eine speziellen Abschnitt für match vs. search , deckt auch mehrzeilige strings:

Python bietet zwei verschiedene primitive
Operationen auf der Grundlage von regelmäßigen
Ausdrücke: match überprüft, ob eine übereinstimmung
nur am Anfang der Zeichenfolge,
während search überprüft, ob eine übereinstimmung
überall in den string (das ist, was
Perl standardmäßig tut).

Beachten Sie, dass match abweichen search
auch wenn mit einem regulären Ausdruck
beginnend mit '^': '^' Spiele nur
am Anfang der Zeichenfolge oder in
MULTILINE - Modus auch sofort
nach einem Zeilenumbruch wird. Die "match"
die Bedienung gelingt nur, wenn das Muster
entspricht der start der string
unabhängig vom Modus oder der Start
position des optionalen pos
argument unabhängig davon, ob eine
newline es vorangeht.

Nun, genug geredet. Zeit finden Sie einige Beispiel-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
```
Was ist mit strings mit newlines?
Warum würde jemand verwenden, beschränkt match eher als allgemeiner search dann? ist es für die Geschwindigkeit?
Spiel ist viel schneller als die Suche, so zu tun, anstatt regex.search("Begriff"), die Sie tun können, regex.match - ((.*?)word(.*?)) und gewinnen Tonnen von performance-arbeiten Sie mit Millionen von Proben.
Gut, das ist doof. Warum nennen Sie es match? Ist es ein cleverer Schachzug, der Samen der API ' s mit unintuitive Namen zwingen mich, die Dokumentation zu Lesen? Ich will immer noch nicht! Rebell!
sieht ein bisschen faster als suchen, wenn mit dem gleichen regulären Ausdruck, aber dein Beispiel scheint falsch, nach einem performance-test: stackoverflow.com/questions/180986/...

InformationsquelleAutor nosklo
82

search ⇒ etwas finden überall in der Zeichenfolge und zurück ein match-Objekt.

match ⇒ fündig bei der Anfang des Strings zurückgeben, die ein match-Objekt.

InformationsquelleAutor Dhanasekaran Anbalagan
46

re.search Suchees für das Muster gesamten string, in der Erwägung, dass re.match hat die Suche nicht das Muster; wenn es nicht, es hat keine andere Wahl, als zu match es am Anfang der Zeichenfolge.

Warum Spiel am start, aber nicht bis zum Ende der Zeichenkette (fullmatch in phyton 3.4)?

InformationsquelleAutor xilun
25

Der Unterschied ist, re.match() in die Irre führt jemand gewohnt Perl, grep, oder sed reguläre Ausdrücke, und re.search() nicht. 🙂

Mehr nüchtern, Als John D. Cook Bemerkungen, re.match() "verhält sich so, als wenn jedes Muster hat ^ vorangestellt." In anderen Worten, re.match('pattern') gleich re.search('^pattern'). So ist es ein Anker-Muster der linken Seite. Aber auch nicht-Anker-Muster - Rechte Seite: das erfordert noch eine abschließende $.

Ehrlich gesagt angesichts der oben genannten, ich denke re.match() werden sollte, abgelehnt. Ich wäre daran interessiert zu wissen, Gründen Sie beibehalten werden soll.

"verhält sich so, als wenn jedes Muster hat ^ vorangestellt." ist nur wahr, wenn Sie nicht verwenden die multiline-option. Die korrekte Aussage ist "... \Einem vorangestellten"

InformationsquelleAutor CODE-REaD
24

können Sie sich das folgende Beispiel zu verstehen, die Arbeit der re.match und re.Suche
```
a = "123abc"
t = re.match("[a-z]+",a)
t = re.search("[a-z]+",a)
```
re.match zurückkehren wird keiner, aber neu.suchen, zurück abc.

Möchte nur hinzufügen, dass die Suche zurück _sre.SRE_Match Objekt (oder Keine, wenn nicht gefunden). Um 'abc', müssen Sie rufen Sie t.Gruppe()

InformationsquelleAutor ldR
24

Spiel ist viel schneller als die Suche, so zu tun, anstatt regex.search("Begriff"), die Sie tun können, regex.match - ((.*?)word(.*?)) und gewinnen Tonnen von performance-arbeiten Sie mit Millionen von Proben.

Dieser Kommentar von @ivan_bilan unter die akzeptierte Antwort oben mir denken, wenn solche hack ist eigentlich die Beschleunigung etwas nach oben, so lasst uns herausfinden, wie viele Tonnen von Leistung, die Sie wirklich gewinnen.

Bereitete ich die folgenden test-suite:
```
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)
```
Ich aus 10 Messungen (1M, 2M, ..., 10M Worte) der gab mir folgenden plot:

Die daraus resultierenden Linien sind erstaunlich (eigentlich nicht überraschend) gerade. Und die search Funktion ist (etwas) schneller angesichts dieses spezifische Muster-Kombination. Die moral von diesem test: Vermeiden overoptimizing code.

+1 für die tatsächlich untersuchen die Annahmen, die hinter einer Aussage gemeint zu sein, für Bare Münze genommen -- danke.
In der Tat der Kommentar von @ivan_bilan falsch aussieht, aber die match Funktion ist immer noch schneller als die search Funktion, wenn Sie vergleichen die gleichen regulären Ausdruck. Können Sie in Ihrem Skript durch Vergleich re.search('^python', word) zu re.match('python', word) (oder re.match('^python', word) das ist das gleiche, aber einfacher zu verstehen, wenn Sie nicht Lesen Sie die Dokumentation und scheint nicht auf die Leistung)
Ich bin nicht einverstanden mit der Aussage, dass die match Funktion ist in der Regel schneller. Die match ist schneller, wenn Sie wollen, suchen Anfang der string, der search ist schneller, wenn Sie wollen, suchen Sie überall die Zeichenfolge. Das entspricht dem gesunden Menschenverstand. Das ist der Grund, warum @ivan_bilan falsch war - er verwendet match Suche in der gesamten Zeichenfolge. Das ist, warum Sie Recht haben - Sie verwendet match zu Suche am Anfang der Zeichenfolge. Wenn Sie nicht einverstanden mit mir, versuchen zu finden, regex für match schneller ist als re.search('python', word) und macht die gleiche Arbeit.
Auch, wie eine Fußnote, die re.match('python') ist geringfügig schneller als re.match('^python'). So muss es sein.
ja, dass ist es, was ich meinte, match - Funktion ist ein bisschen schneller, wenn Sie wollen zu Suche am Anfang der Zeichenfolge (im Vergleich zu search Funktion, um ein Wort am Anfang einer Zeichenfolge mit re.search('^python', word) zum Beispiel). Aber ich finde das komisch, wenn Sie sagen, die search - Funktion für die Suche auf den Anfang eines Strings, sollte es so schnell wie die match Funktion.

InformationsquelleAutor Jeyekomon
14

re.match versucht ein Muster am Anfang der Zeichenfolge. re.Suche versucht, die Muster gesamten string, bis es eine übereinstimmung findet.

InformationsquelleAutor cschol
1

Viel kürzer:
- search durchsucht Trog ganzen string.
- match Tut nur der Anfang der Zeichenkette.
Folgenden Ex sagt es:
```
>>> a = "123abc"
>>> re.match("[a-z]+",a)
None
>>> re.search("[a-z]+",a)
abc
```
InformationsquelleAutor U9-Forward

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.