re_spam.py
# -*- coding: utf-8 -*-
import re
re.match("spa*m", "spam") #Verstehen
spam = re.compile("spa*m")
spam.match("spaaaaaaaam") #Verstehen
re.match(spam, "spaaaam") #Es funktioniert aus irgendeinem Grund
Das reguläre Ausdrucksobjekt, das durch re.compile wie oben beschrieben erhalten wurde, kann für das re.match-Muster verwendet werden. Es scheint, dass vorläufig bestimmt wird, ob das als Muster übergebene Objekt ein Objekt mit regulären Ausdrücken ist.
Gibt es einen Vorteil bei dieser Methode? Die Verarbeitungsgeschwindigkeit ist langsamer als bei Verwendung von re.match.
Dies ist die Quelle von Python-1.5.2 (Auszug)
re.py
def _cachecompile(pattern, flags=0):
key = (pattern, flags)
try:
return _cache[key]
except KeyError:
pass
value = compile(pattern, flags)
if len(_cache) >= _MAXCACHE:
_cache.clear()
_cache[key] = value
return value
def match(pattern, string, flags=0):
return _cachecompile(pattern, flags).match(string)
def compile(pattern, flags=0):
"Compile a regular expression pattern, returning a RegexObject."
groupindex={}
code=pcre_compile(pattern, flags, groupindex)
return RegexObject(pattern, flags, code, groupindex)
Es gibt keine besondere Prüfung. Dann Python-2.0.1 sre.py (Auszug)
sre.py
def match(pattern, string, flags=0):
"""Try to apply the pattern at the start of the string, returning
a match object, or None if no match was found."""
return _compile(pattern, flags).match(string)
def _compile(*key):
# internal: compile pattern
p = _cache.get(key)
if p is not None:
return p
pattern, flags = key
if type(pattern) not in sre_compile.STRING_TYPES:
return pattern
try:
p = sre_compile.compile(pattern, flags)
except error, v:
raise error, v # invalid expression
if len(_cache) >= _MAXCACHE:
_cache.clear()
_cache[key] = p
return p
Es scheint, dass das Muster so zurückgegeben wird, wie es ist, wenn es keine kompilierbare Zeichenfolge ist. Und Python-2.7.9 re.py (Auszug)
re.py
def match(pattern, string, flags=0):
"""Try to apply the pattern at the start of the string, returning
a match object, or None if no match was found."""
return _compile(pattern, flags).match(string)
def _compile(*key):
# internal: compile pattern
pattern, flags = key
bypass_cache = flags & DEBUG
if not bypass_cache:
cachekey = (type(key[0]),) + key
try:
p, loc = _cache[cachekey]
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"
try:
p = sre_compile.compile(pattern, flags)
except error, v:
raise error, v # invalid expression
if not bypass_cache:
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[cachekey] = p, loc
return p
Zusätzlich zur Überprüfung, ob das Muster eine Zeichenfolge ist, wird auch überprüft, ob es kompiliert wurde, und es wird eindeutig angegeben, dass "das erste Argument eine Zeichenfolge oder ein kompiliertes Muster sein muss".
Recommended Posts