Lohnt es sich Pythons re.compile zu verwenden?

Ich habe eine Menge Erfahrung in der Leitung einer kompilierten regex 1000 mal gegen das kompilieren " on-the-fly, und habe nicht bemerkt, jede wahrnehmbare Unterschied. Offensichtlich, dies ist anekdotisch, und sicherlich nicht ein tolles argument gegen kompilieren, aber ich habe festgestellt, das der Unterschied zu vernachlässigen sein.

BEARBEITEN:
Nach einem kurzen Blick auf die aktuelle Python 2.5 library code, sehe ich, dass Python intern kompiliert UND ZWISCHENGESPEICHERT regexes immer dann, wenn Sie Sie sowieso (einschließlich Anrufe bei re.match()), du bist also wirklich nur ändern, WENN der reguläre Ausdruck kompiliert wird, und sollte nicht viel Zeit einzusparen überhaupt - nur die Zeit, die es braucht, um den cache prüfen (ein-Schlüssel-lookup auf eine interne dict - Typ).

Vom Modul re.py (Kommentare sind von mir):

def match(pattern, string, flags=0):
    return _compile(pattern, flags).match(string)

def _compile(*key):

    # Does cache check at top of function
    cachekey = (type(key[0]),) + key
    p = _cache.get(cachekey)
    if p is not None: return p

    # ...
    # Does actual compilation on cache miss
    # ...

    # Caches compiled regex
    if len(_cache) >= _MAXCACHE:
        _cache.clear()
    _cache[cachekey] = p
    return p

Ich noch oft vor-kompilieren von regulären Ausdrücken, aber nur, um Sie zu binden, um eine schöne, wiederverwendbare Namen, nicht für die erwartete Leistung zu gewinnen.

InformationsquelleAutor der Antwort Triptych

FWIW:

$ python -m timeit -s "import re" "re.match('hello', 'hello world')"
100000 loops, best of 3: 3.82 usec per loop

$ python -m timeit -s "import re; h=re.compile('hello')" "h.match('hello world')"
1000000 loops, best of 3: 1.26 usec per loop

so, wenn du gehst, werden mithilfe der gleichen regex viel, kann es sich lohnen, es zu tun re.compile (insbesondere bei komplexeren regexes).

Die standard-Argumente gegen die vorzeitige Optimierung anwenden, aber ich glaube nicht, dass Sie wirklich verlieren viel Klarheit/Eindeutigkeit durch die Verwendung von re.compile wenn Sie vermuten, dass Ihr regexps kann zu einem performance-Engpass.

InformationsquelleAutor der Antwort dF.

Ich habe gerade versucht diese selbst. Für den einfachen Fall der Analyse einer Zahl aus einem string und addieren es, die Verwendung einer kompilierten regulären Ausdruck Objekt ist etwa doppelt so schnell sein wie der re Methoden.

Als andere haben darauf hingewiesen, dass der re Methoden (einschließlich re.compile) schauen den regulären Ausdruck in einen cache von bereits kompilierten Ausdrücke. Also im normal Fall werden die zusätzlichen Kosten für die Nutzung der re Methoden ist einfach die Kosten für die cache-Suche.

Jedoch, die Prüfung der codezeigt der cache ist auf 100 beschränkt Ausdrücken. Dies wirft die Frage auf, wie schmerzhaft ist es zu einem überlauf der cache? Der code enthält einen internen interface, um den regulären Ausdruck, compiler, re.sre_compile.compile. Wenn wir es nennen, wir der cache umgangen. Es stellt sich heraus, dass etwa zwei Größenordnungen langsamer für einen einfachen regulären Ausdruck, wie r'\w+\s+([0-9_]+)\s+\w*'.

Hier mein test:

#!/usr/bin/env python
import re
import time

def timed(func):
    def wrapper(*args):
        t = time.time()
        result = func(*args)
        t = time.time() - t
        print '%s took %.3f seconds.' % (func.func_name, t)
        return result
    return wrapper

regularExpression = r'\w+\s+([0-9_]+)\s+\w*'
testString = "average    2 never"

@timed
def noncompiled():
    a = 0
    for x in xrange(1000000):
        m = re.match(regularExpression, testString)
        a += int(m.group(1))
    return a

@timed
def compiled():
    a = 0
    rgx = re.compile(regularExpression)
    for x in xrange(1000000):
        m = rgx.match(testString)
        a += int(m.group(1))
    return a

@timed
def reallyCompiled():
    a = 0
    rgx = re.sre_compile.compile(regularExpression)
    for x in xrange(1000000):
        m = rgx.match(testString)
        a += int(m.group(1))
    return a


@timed
def compiledInLoop():
    a = 0
    for x in xrange(1000000):
        rgx = re.compile(regularExpression)
        m = rgx.match(testString)
        a += int(m.group(1))
    return a

@timed
def reallyCompiledInLoop():
    a = 0
    for x in xrange(10000):
        rgx = re.sre_compile.compile(regularExpression)
        m = rgx.match(testString)
        a += int(m.group(1))
    return a

r1 = noncompiled()
r2 = compiled()
r3 = reallyCompiled()
r4 = compiledInLoop()
r5 = reallyCompiledInLoop()
print "r1 = ", r1
print "r2 = ", r2
print "r3 = ", r3
print "r4 = ", r4
print "r5 = ", r5
</pre>
And here is the output on my machine:
<pre>
$ regexTest.py 
noncompiled took 4.555 seconds.
compiled took 2.323 seconds.
reallyCompiled took 2.325 seconds.
compiledInLoop took 4.620 seconds.
reallyCompiledInLoop took 4.074 seconds.
r1 =  2000000
r2 =  2000000
r3 =  2000000
r4 =  2000000
r5 =  20000

'ReallyCompiled' Methoden verwenden Sie die interne Schnittstelle, das umgeht den cache. Beachten Sie die eine, die kompiliert auf jeder loop-iteration wird nur iteriert 10.000 mal, nicht eine million.

InformationsquelleAutor der Antwort George

Meist gibt es kaum einen Unterschied, ob Sie re.kompilieren oder nicht. Intern, alle Funktionen sind implementiert, ein compile-Schritt:

def match(pattern, string, flags=0):
    return _compile(pattern, flags).match(string)

def fullmatch(pattern, string, flags=0):
    return _compile(pattern, flags).fullmatch(string)

def search(pattern, string, flags=0):
    return _compile(pattern, flags).search(string)

def sub(pattern, repl, string, count=0, flags=0):
    return _compile(pattern, flags).sub(repl, string, count)

def subn(pattern, repl, string, count=0, flags=0):
    return _compile(pattern, flags).subn(repl, string, count)

def split(pattern, string, maxsplit=0, flags=0):
    return _compile(pattern, flags).split(string, maxsplit)

def findall(pattern, string, flags=0):
    return _compile(pattern, flags).findall(string)

def finditer(pattern, string, flags=0):
    return _compile(pattern, flags).finditer(string)

Zusätzlich, re.compile() umgeht den extra Umweg und Logik:

_cache = {}

_pattern_type = type(sre_compile.compile("", 0))

_MAXCACHE = 512
def _compile(pattern, flags):
    # internal: compile pattern
    try:
        p, loc = _cache[type(pattern), pattern, flags]
        if loc is None or loc == _locale.setlocale(_locale.LC_CTYPE):
            return p
    except KeyError:
        pass
    if isinstance(pattern, _pattern_type):
        if flags:
            raise ValueError(
                "cannot process flags argument with a compiled pattern")
        return pattern
    if not sre_compile.isstring(pattern):
        raise TypeError("first argument must be string or compiled pattern")
    p = sre_compile.compile(pattern, flags)
    if not (flags & DEBUG):
        if len(_cache) >= _MAXCACHE:
            _cache.clear()
        if p.flags & LOCALE:
            if not _locale:
                return p
            loc = _locale.setlocale(_locale.LC_CTYPE)
        else:
            loc = None
        _cache[type(pattern), pattern, flags] = p, loc
    return p

Neben der kleinen Geschwindigkeit nutzen von re.kompilierendie Menschen auch wie die Lesbarkeit, das kommt von der Benennung potenziell komplexen Muster, Spezifikationen und trennen Sie Sie von der business-Logik, wo es angewendet werden:

#### Patterns ############################################################
number_pattern = re.compile(r'\d+(\.\d*)?')    # Integer or decimal number
assign_pattern = re.compile(r':=')             # Assignment operator
identifier_pattern = re.compile(r'[A-Za-z]+')  # Identifiers
whitespace_pattern = re.compile(r'[\t ]+')     # Spaces and tabs

#### Applications ########################################################

if whitespace_pattern.match(s): business_logic_rule_1()
if assign_pattern.match(s): business_logic_rule_2()

Hinweis, eine andere befragte fälschlicherweise angenommen, dass pyc gespeicherten Dateien kompiliert Muster direkt; aber in Wirklichkeit sind Sie wieder aufgebaut, jedes mal, wenn die PYC ist geladen:

>>> from dis import dis
>>> with open('tmp.pyc', 'rb') as f:
        f.read(8)
        dis(marshal.load(f))

  1           0 LOAD_CONST               0 (-1)
              3 LOAD_CONST               1 (None)
              6 IMPORT_NAME              0 (re)
              9 STORE_NAME               0 (re)

  3          12 LOAD_NAME                0 (re)
             15 LOAD_ATTR                1 (compile)
             18 LOAD_CONST               2 ('[aeiou]{2,5}')
             21 CALL_FUNCTION            1
             24 STORE_NAME               2 (lc_vowels)
             27 LOAD_CONST               1 (None)
             30 RETURN_VALUE

Den oben Demontage kommt von der PYC-Datei für eine tmp.py mit:

import re
lc_vowels = re.compile(r'[aeiou]{2,5}')

InformationsquelleAutor der Antwort Raymond Hettinger

Anhand der vorgegebenen Beispiele:

h = re.compile('hello')
h.match('hello world')

Den match - Methode im obigen Beispiel ist nicht dieselbe wie die, die unten verwendet:

re.match('hello', 'hello world')

re.compile() gibt eine regular expression-Objektswas bedeutet, dass h ist ein regex-Objekt.

Den regex-Objekt hat seine eigene match Methode mit dem optionalen pos und endpos Parameter:

regex.match(string[, pos[, endpos]])

pos

Den optionalen zweiten parameter pos gibt einen index in der Zeichenfolge, wo
die Suche wird gestartet; es wird standardmäßig auf 0. Diese ist nicht vollständig
äquivalent zum schneiden der Schnur; der '^' Muster-Zeichen-Spiele an
der eigentliche Anfang des Strings und an den Positionen nur nach einer
newline, aber nicht unbedingt in der index, wo die Suche ist
start.

endpos

Den optionalen parameter endpos Grenzen, wie weit der string wird
gesucht; es wird sein, als ob die Zeichenfolge endpos Zeichen lang, so
nur die Zeichen von pos zu endpos - 1 gesucht wird ein
match. Wenn endpos ist weniger als pos keine übereinstimmung gefunden wird; andernfalls
wenn rx ist ein kompilierter regulärer Ausdruck Objekt rx.search(string, 0,
50) entspricht rx.search(string[:50], 0).

Des regex-Objekts Suchefindallund finditer Methoden unterstützen auch diese Parameter.

re.match(pattern, string, flags=0) nicht zu unterstützen, wie Sie sehen können,

noch hat seine Suche, findall, und finditer Kollegen.

Einen match-Objekt hat Attribute, ergänzen diese Parameter:

übereinstimmen.pos

Den Wert von pos, die übergeben wurde, um die search() oder match () - Methode von
ein regex-Objekt. Dies ist der index im string, an dem der RE
Motor gestartet, nach einem match sucht.

übereinstimmen.endpos

Den Wert der endpos, die übergeben wurde, um die search() oder match () - Methode
eines regex-Objekts. Dies ist der index in der Zeichenfolge, ab dem die
RE-engine wird nicht gehen.

Einen regex-Objekt hat zwei einzigartige, möglicherweise nützlich, attributes:

regex.Gruppen

Die Anzahl der erfassungsgruppen im Muster.

regex.groupindex

Wörterbuch-mapping symbolischen Gruppennamen definiert durch (?P)
Gruppe-zahlen. Das Wörterbuch ist leer, wenn keine symbolische Gruppen verwendet wurden
in das Muster.

Schließlich match-Objekt hat dieses Attribut:

übereinstimmen.re

Den regulären Ausdruck Objekt, dessen match() oder search () - Methode
produziert wird dieses match Instanz.

InformationsquelleAutor der Antwort Honest Abe

Interessant auszuwerten, um nicht als effizienter für mich (Python 2.5.2 auf Win XP):

import re
import time

rgx = re.compile('(\w+)\s+[0-9_]?\s+\w*')
str = "average    2 never"
a = 0

t = time.time()

for i in xrange(1000000):
    if re.match('(\w+)\s+[0-9_]?\s+\w*', str):
    #~ if rgx.match(str):
        a += 1

print time.time() - t

Ausführen der oben genannten code mal so wie es ist, und einmal mit den beiden if Linien, kommentierte der andere Weg herum, die zusammengestellt regex ist doppelt so schnell

InformationsquelleAutor der Antwort Eli Bendersky

Performance-Unterschied abgesehen, mit re.kompilieren und mit der kompilierten regulären Ausdruck Objekt übereinstimmen (was auch immer reguläre Ausdruck verbundene Vorgänge) macht die Semantik klarer Python-Laufzeit.

Hatte ich einige schmerzhafte Erfahrungen Debuggen einige einfache code:

compare = lambda s, p: re.match(p, s)

und später würde ich verwenden, zu vergleichen, in

[x for x in data if compare(patternPhrases, x[columnIndex])]

wo patternPhrases soll eine variable, die den regulären Ausdruck string x[columnIndex] ist eine variable, die die Zeichenkette.

Hatte ich Mühe, die patternPhrases nicht mit der zu erwartenden string!

Aber wenn ich die re.kompilieren form:

compare = lambda s, p: p.match(s)

dann in

[x for x in data if compare(patternPhrases, x[columnIndex])]

Python würde haben sich beschwert, dass "Zeichenfolge nicht über das Attribut der match", als durch positionelle argument-mapping in comparex[columnIndex] ist als regulärer Ausdruck verwendet!, wenn ich meinte eigentlich

compare = lambda p, s: p.match(s)

In meinem Fall, mit re.kompilieren ist expliziter Zweck der reguläre Ausdruck, wenn der Wert ausgeblendet ist, Nackte Augen, so konnte ich weitere Hilfe von Python-run-time-Prüfung.

Also die moral von meinem Lektion ist, dass, wenn der reguläre Ausdruck ist nicht nur wörtlich string, dann sollte ich über die re.kompilieren zu lassen, Python, mir zu helfen, zu behaupten, meine Annahme.

InformationsquelleAutor der Antwort

Neben der Leistung.

Mit compile hilft mir zu unterscheiden, die Konzepte

1. Modul(re),

2. regex-Objekt

3. match-Objekt

Als ich angefangen zu lernen, regex

#regex object
regex_object = re.compile(r'[a-zA-Z]+')
#match object
match_object = regex_object.search('1.Hello')
#matching content
match_object.group()
output:
Out[60]: 'Hello'
V.S.
re.search(r'[a-zA-Z]+','1.Hello').group()
Out[61]: 'Hello'

Als Ergänzung, ich machte eine umfassende cheatsheet von Modul re für Ihre Referenz.

regex = {
'brackets':{'single_character': ['[]', '.', {'negate':'^'}],
            'capturing_group' : ['()','(?:)', '(?!)' '|', '\\', 'backreferences and named group'],
            'repetition'      : ['{}', '*?', '+?', '??', 'greedy v.s. lazy ?']},
'lookaround' :{'lookahead'  : ['(?=...)', '(?!...)'],
            'lookbehind' : ['(?<=...)','(?<!...)'],
            'caputuring' : ['(?P<name>...)', '(?P=name)', '(?:)'],},
'escapes':{'anchor'          : ['^', '\b', '$'],
          'non_printable'   : ['\n', '\t', '\r', '\f', '\v'],
          'shorthand'       : ['\d', '\w', '\s']},
'methods': {['search', 'match', 'findall', 'finditer'],
              ['split', 'sub']},
'match_object': ['group','groups', 'groupdict','start', 'end', 'span',]
}

InformationsquelleAutor der Antwort JawSaw

Ich respektiere wirklich alle oben genannten Antworten. Aus meiner Meinung nach
Ja! Sicher lohnt es sich, über die re.kompilieren kompilieren der regex, wieder und wieder, jedes mal.

Mit re.kompilieren macht den code dynamischer, wie Sie Sie nennen können, die bereits regex kompiliert, kompilieren, wieder und abermals. Dieses Ding Vorteile, die Sie in den Fällen, in:

1. Prozessor Bemühungen
2. Zeit Komplexität.
3. Macht regex Universal.(kann verwendet werden, findall, Suche, match)
4. Und macht das Programm sieht cool aus.

Beispiel :

  example_string = "The room number of her room is 26A7B."
  find_alpha_numeric_string = re.compile(r"\b\w+\b")

Mit in Findall

 find_alpha_numeric_string.findall(example_string)

Mit in die Suche

  find_alpha_numeric_string.search(example_string)

Ähnlich können Sie es verwenden für: Match und Ersatz

InformationsquelleAutor der Antwort The Gr8 Adakron

Ich habe eine Menge Erfahrung in der Leitung einer kompilierten regex-1000s
mal versus kompilieren " on-the-fly, und habe nicht bemerkt,
jeder wahrnehmbare Unterschied

Stimmen auf die akzeptierte Antwort führt zu der Annahme, dass das, was @Triptychon sagt, ist wahr für alle Fälle. Dies ist nicht unbedingt wahr. Ein großer Unterschied ist, wenn Sie haben zu entscheiden, ob zu akzeptieren, die ein regex-string oder eine kompilierte regex-Objekts als parameter an eine Funktion:

>>> timeit.timeit(setup="""
... import re
... f=lambda x, y: x.match(y)       # accepts compiled regex as parameter
... h=re.compile('hello')
... """, stmt="f(h, 'hello world')")
0.32881879806518555
>>> timeit.timeit(setup="""
... import re
... f=lambda x, y: re.compile(x).match(y)   # compiles when called
... """, stmt="f('hello', 'hello world')")
0.809190034866333

Ist es immer besser, zu kompilieren, regexs in den Fall, Sie brauchen, um Sie wiederzuverwenden.

Hinweis: das Beispiel in der timeit oben simuliert die Erstellung einer kompilierten regex-Objekt, sobald beim import versus "on-the-fly", wenn erforderlich, für ein Spiel.

InformationsquelleAutor der Antwort lonetwin

möchte ich motivieren, dass pre-compiling ist sowohl konzeptionell und 'literately' (wie in 'literate programming') vorteilhaft. haben Sie einen Blick auf dieses code-snippet:

from re import compile as _Re

class TYPO:

  def text_has_foobar( self, text ):
    return self._text_has_foobar_re_search( text ) is not None
  _text_has_foobar_re_search = _Re( r"""(?i)foobar""" ).search

TYPO = TYPO()

in Ihrer Anwendung, Sie würde schreiben:

from TYPO import TYPO
print( TYPO.text_has_foobar( 'FOObar ) )

dies ist etwa so einfach, in Bezug auf Funktionalität, wie es bekommen kann. weil dieses Beispiel ist so kurz, ich zusammengefasst der Weg, um _text_has_foobar_re_search alle in einer Zeile. der Nachteil bei diesem code ist, dass es nimmt wenig Speicher für das, was der Lebensdauer der TYPO library-Objekt ist; der Vorteil ist, dass wenn Sie einen Tee suchen, werden Sie Weg mit zwei Funktionsaufrufe und die zwei-Klassen-Wörterbuch lookups. wie viele regexes zwischengespeichert werden durch re und der Aufwand, die Caches sind hier irrelevant.

vergleichen Sie diese mit den üblichen Stil, unten:

import re

class Typo:

  def text_has_foobar( self, text ):
    return re.compile( r"""(?i)foobar""" ).search( text ) is not None

In der Anwendung:

typo = Typo()
print( typo.text_has_foobar( 'FOObar ) )

Ich gebe zu, dass mein Stil ist sehr ungewöhnlich für python, vielleicht sogar fraglich. im Beispiel ist aber, dass genau entspricht, wie python wird meist verwendet, um ein einzelnes Spiel, müssen wir instanziieren ein Objekt, können Sie drei Beispiel-Wörterbuch lookups, und führen Sie drei Funktionsaufrufe; darüber hinaus könnten wir bekommen, in re caching-Probleme bei der Verwendung von mehr als 100 regexes. auch mit dem regulären Ausdruck steht, verdeckt innerhalb der Methode Körper, die meisten der Zeit, ist nicht so eine gute Idee.

sei es gesagt, daß jede Teilmenge der Maßnahmen---gezielte, alias import-Anweisungen; alias-Methoden, wo zutreffend; Reduktion der Funktionsaufrufe und die Objekt-dictionary lookups---kann dazu beitragen, rechnerische und begriffliche Komplexität.

InformationsquelleAutor der Antwort flow