Alternative zum `match = re.match(); wenn Übereinstimmung: ... `Idiom?

Question

Wenn Sie überprüfen wollen, ob etwas einen regulären Ausdruck übereinstimmt, wenn ja, die erste Gruppe drucken, was Sie tun ..

import re 
match = re.match("(\d+)g", "123g") 
if match is not None: 
    print match.group(1) 

Das ist völlig pedantisch, aber die Zwischen match Variable ist ein bisschen ärgerlich ..

Sprachen wie Perl tun dies, indem neue $1 Schaffung .. $9 Variablen für Match-Gruppen, wie ..

if($blah ~= /(\d+)g/){ 
    print $1 
} 

von this reddit comment,

with re_context.match('^blah', s) as match: 
    if match: 
     ... 
    else: 
     ... 

..welche ich dachte, war eine interessante Idee, so schrieb ich eine einfache Implementierung davon: Es

#!/usr/bin/env python2.6 
import re 

class SRE_Match_Wrapper: 
    def __init__(self, match): 
     self.match = match 

    def __exit__(self, type, value, tb): 
     pass 

    def __enter__(self): 
     return self.match 

    def __getattr__(self, name): 
     if name == "__exit__": 
      return self.__exit__ 
     elif name == "__enter__": 
      return self.__name__ 
     else: 
      return getattr(self.match, name) 

def rematch(pattern, inp): 
    matcher = re.compile(pattern) 
    x = SRE_Match_Wrapper(matcher.match(inp)) 
    return x 
    return match 

if __name__ == '__main__': 
    # Example: 
    with rematch("(\d+)g", "123g") as m: 
     if m: 
      print(m.group(1)) 

    with rematch("(\d+)g", "123") as m: 
     if m: 
      print(m.group(1)) 

(Diese Funktionalität theoretisch in das _sre.SRE_Match Objekt gepatcht werden könnte)

wäre schön, wenn Sie die Ausführung des Codeblocks der with Anweisung überspringen könnten, wenn es keine Übereinstimmung gäbe, die das vereinfachen würde.

with rematch("(\d+)g", "123") as m: 
    print(m.group(1)) # only executed if the match occurred 

..aber dies unmöglich scheint anhand dessen, was ich von PEP 343

Irgendwelche Ideen ableiten kann? Wie gesagt, das ist wirklich trivialer Ärger, fast bis zum Code-Golf.

Answer 1

Ich glaube nicht, dass es trivial ist. Ich möchte nicht eine redundante Bedingung um meinen Code streuen müssen, wenn ich Code so häufig schreibe.

Dies ist etwas seltsam, aber man kann mit einem Iterator dies tun:

import re 

def rematch(pattern, inp): 
    matcher = re.compile(pattern) 
    matches = matcher.match(inp) 
    if matches: 
     yield matches 

if __name__ == '__main__': 
    for m in rematch("(\d+)g", "123g"): 
     print(m.group(1)) 

Das Seltsame ist, dass es einen Iterator für etwas ist, verwenden, die nicht iteriert - es ist näher an einem bedingten, und Auf den ersten Blick sieht es so aus, als würde es für jedes Spiel mehrere Ergebnisse liefern.

Es scheint seltsam, dass ein Kontextmanager nicht dazu führen kann, dass seine verwaltete Funktion vollständig übersprungen wird; obwohl das nicht explizit einer der Anwendungsfälle von "mit" ist, scheint es eine natürliche Erweiterung zu sein.

Answer 2

Ich glaube nicht, with ist die Lösung in diesem Fall. Sie müssten eine Ausnahme im BLOCK-Teil (der vom Benutzer angegeben wurde) auslösen und die __exit__-Methode True zurückgeben, um die Ausnahme zu "verschlucken". So würde es nie gut aussehen.

Ich würde vorschlagen, für eine Syntax ähnlich der Perl-Syntax gehen. Machen Sie Ihre eigenen erweitert re Modul (ich nenne es rex) und haben es die Variablen in seiner Modul-Namensraum:

if rex.match('(\d+)g', '123g'): 
    print rex._1 

Wie Sie in den Kommentaren unten sehen können, ist dieses Verfahren weder Scope- noch thread-safe . Sie würden dies nur verwenden, wenn Sie absolut sicher wären, dass Ihre Anwendung in Zukunft nicht multi-threaded wird und dass alle Funktionen, die aus dem Bereich aufgerufen werden, in dem Sie diese verwenden, auch die gleiche Methode verwenden.

Answer 3

Wenn Sie eine Menge davon an einem Ort tun, hier ist eine Alternative Antwort:

import re 
class Matcher(object): 
    def __init__(self): 
     self.matches = None 
    def set(self, matches): 
     self.matches = matches 
    def __getattr__(self, name): 
     return getattr(self.matches, name) 

class re2(object): 
    def __init__(self, expr): 
     self.re = re.compile(expr) 

    def match(self, matcher, s): 
     matches = self.re.match(s) 
     matcher.set(matches) 
     return matches 

pattern = re2("(\d+)g") 
m = Matcher() 
if pattern.match(m, "123g"): 
    print(m.group(1)) 
if not pattern.match(m, "x123g"): 
    print "no match" 

Sie die Regex einmal mit der gleichen Thread-Sicherheit wie Re, erstellen Sie ein einzelnes wiederverwendbares Matcher Objekt kompilieren die ganze Funktion, und dann können Sie es sehr prägnant verwenden. Dies hat auch den Vorteil, dass Sie es auf die offensichtliche Weise umkehren können - um dies mit einem Iterator zu tun, müssten Sie ein Flag übergeben, um es zu veranlassen, sein Ergebnis zu invertieren.

Es ist nicht viel hilfreich, wenn Sie nur eine einzige Übereinstimmung pro Funktion machen, obwohl; Sie möchten Matcher-Objekte nicht in einem breiteren Kontext halten; Es würde die gleichen Probleme wie Blixt Lösung verursachen. Diese

Answer 4

ist nicht wirklich hübsch aussehende, aber Sie können von der getattr(object, name[, default]) eingebaute Funktion verwenden es wie folgt profitieren:

>>> getattr(re.match("(\d+)g", "123g"), 'group', lambda n:'')(1) 
'123' 
>>> getattr(re.match("(\d+)g", "X23g"), 'group', lambda n:'')(1) 
'' 

zu imitieren die wenn Match Druckgruppe Flow, können Sie (ab verwenden) auf diese Weise die for Aussage:

>>> for group in filter(None, [getattr(re.match("(\d+)g", "123g"), 'group', None)]): 
     print(group(1)) 
123 
>>> for group in filter(None, [getattr(re.match("(\d+)g", "X23g"), 'group', None)]): 
     print(group(1)) 
>>> 

natürlich können Sie eine kleine Funktion definieren können, die schmutzige Arbeit zu tun:

>>> matchgroup = lambda p,s: filter(None, [getattr(re.match(p, s), 'group', None)]) 
>>> for group in matchgroup("(\d+)g", "123g"): 
     print(group(1)) 
123 
>>> for group in matchgroup("(\d+)g", "X23g"): 
     print(group(1)) 
>>> 

Answer 5

nicht die perfekte Lösung, aber Dich Kette mehr Spiel-Optionen für die gleiche str erlaubt:

header = re.compile('(.*?) = (.*?)$') 
footer = re.compile('(.*?): (.*?)$') 

if header.match(line) as m: 
    key, value = m.group(1,2) 
elif footer.match(line) as m 
    key, value = m.group(1,2) 
else: 
    key, value = None, None 

Answer 6

Eine weitere nette Syntax so etwas wie dies würde Art und Weise, dies zu tun, basierend auf Glen Maynard Lösung:

for match in [m for m in [re.match(pattern,key)] if m]: 
    print "It matched: %s" % match 

ähnlich wie Glen-Lösung, diese itte Raten entweder 0 (wenn keine Übereinstimmung) oder 1 (wenn eine Übereinstimmung) mal.

Kein Sub benötigt, aber weniger sauber als Ergebnis.

Answer 7

Ich habe eine andere:

class MatchWrapper(object): 
    def __init__(self): 
    self._matcher = None 

    def wrap(self, matcher): 
    self._matcher = matcher 

    def __getattr__(self, attr): 
    return getattr(self._matcher, attr) 

def match(pattern, s, matcher): 
    m = re.match(pattern, s) 
    if m: 
    matcher.wrap(m) 
    return True 
    else: 
    return False 

matcher = MatchWrapper() 
s = "123g"; 
if _match("(\d+)g", line, matcher): 
    print matcher.group(1) 
elif _match("(\w+)g", line, matcher): 
    print matcher.group(1) 
else: 
    print "no match" 

Answer 8

Hier ist meine Lösung:

import re 

s = 'hello world' 

match = [] 
if match.append(re.match('w\w+', s)) or any(match): 
    print('W:', match.pop().group(0)) 
elif match.append(re.match('h\w+', s)) or any(match): 
    print('H:', match.pop().group(0)) 
else: 
    print('No match found') 

Sie so viele elif Klauseln je nach Bedarf verwenden können.

Noch besser:

import re 

s = 'hello world' 

if vars().update(match=re.match('w\w+', s)) or match: 
    print('W:', match.group(0)) 
elif vars().update(match=re.match('h\w+', s)) or match: 
    print('H:', match.group(0)) 
else: 
    print('No match found') 

Beide anhängen und Update Rückkehr Keine. Sie müssen also das Ergebnis Ihres Ausdrucks überprüfen, indem Sie in jedem Fall den oder Teil verwenden.

Leider funktioniert das nur so lange, wie der Code oberste Ebene befindet, d. H. Nicht in einer Funktion.Diese

Answer 9

ist, was ich tue:

def re_match_cond (match_ref, regex, text): 
    match = regex.match (text) 
    del match_ref[:] 
    match_ref.append (match) 
    return match 

if __name__ == '__main__': 
    match_ref = [] 
    if re_match_cond (match_ref, regex_1, text): 
     match = match_ref[0] 
     ### ... 
    elif re_match_cond (match_ref, regex_2, text): 
     match = match_ref[0] 
     ### ... 
    elif re_match_cond (match_ref, regex_3, text): 
     match = match_ref[0] 
     ### ... 
    else: 
     ### no match 
     ### ... 

Das heißt, gebe ich eine Liste an die Funktion Pass-by-reference zu emulieren.