re_spam.py
# -*- coding: utf-8 -*-
import re
re.match("spa*m", "spam") #Reconnaître
spam = re.compile("spa*m")
spam.match("spaaaaaaaam") #Reconnaître
re.match(spam, "spaaaam") #Cela fonctionne pour une raison quelconque
L'objet d'expression régulière obtenu par re.compile comme décrit ci-dessus peut être utilisé pour le modèle re.match. Il semble qu'il soit provisoirement déterminé si le modèle passé en tant que modèle est un objet d'expression régulière.
Y a-t-il un mérite à cette méthode? La vitesse de traitement est plus lente que l'utilisation de re.match.
Ceci est la source de Python-1.5.2 (extrait)
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)
Il n'y a pas de contrôle particulier. Puis Python-2.0.1 sre.py (extrait)
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
Il semble que le modèle soit renvoyé tel quel s'il ne s'agit pas d'une chaîne de caractères compilable. Et Python-2.7.9 re.py (extrait)
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
En plus de vérifier si le modèle est une chaîne, il vérifie également s'il a été compilé et indique clairement que "le premier argument doit être une chaîne ou un modèle compilé".
Recommended Posts