Reguläre Python-Ausdrücke

Reguläre Ausdrücke sind eine leistungsstarke und standardmäßige Methode zum Suchen, Ersetzen und Parsen komplexer Zeichenfolgen. Alle regulären Ausdrücke in Python befinden sich im re-Modul.

1 Häufige Übereinstimmungen

^passt auf den Anfang der Zeichenfolge zu

$trifft auf das Ende der Zeichenfolge zu

btrifft auf die Grenze eines Wortes zu

d entspricht einer beliebigen Zahl

D entspricht einem beliebigen nicht numerischen Zeichen

x? entspricht einem optionalen x (entspricht 1 oder 0 x Zeichen)

x* Übereinstimmung mit x

x 0 oder öfter. Übereinstimmung mit x

x{n,m} 1 oder öfter, mindestens n-mal und höchstens m-mal x

(a| b |c) entspricht entweder a oder b oder entspricht c

(x) stellt im Allgemeinen eine Speichergruppe dar. Sie können die Funktion groups() des von der Funktion re.search zurückgegebenen Objekts verwenden, um diese abzurufen Wert

2 Allgemeiner Zweck

#-------------------------------------------------------------------------------
# coding:        utf-8
# Purpose:正则表达式
#
# Author:      zdk
#
# Created:     26/02/2013
# Copyright:   (c) zdk 2013
#-------------------------------------------------------------------------------
  
import re
if __name__ == '__main__':
    addr = "100 BROAD ROAD APT.3"
    print(re.sub("ROAD","RD",addr)) # 100 BRD RD APT.3
    print(re.sub(r"\bROAD\b","RD",addr)) # 100 BROAD RD APT.3
    pattern = ".*B.*(ROAD)?"
    print(re.search(pattern,"ROAD")) #None
    print(re.search(pattern,"B")) #<_sre.SRE_Match object at 0x0230F020><span style="background-color:#FAFAFA;font-family:Monaco, &#39;DejaVu Sans Mono&#39;, &#39;Bitstream Vera Sans Mono&#39;, Consolas, &#39;Courier New&#39;, monospace;font-size:1em;line-height:1.5;"> </span>

(1) re.sub("ROAD","RD",addr) Verwenden Sie die Funktion re.sub, um die Zeichenfolge addr zu durchsuchen, um die Anforderungen zu erfüllen Ausdruck Ersetzen Sie

durch „RD“ in der Formel „ROAD“ (2) re.sub(r“bROADb“, „RD“, addr), „b“ bedeutet „Wortgrenze“, in Python, Da Das Zeichen „“ muss in der Zeichenfolge maskiert werden. Dies kann sehr problematisch werden. Daher verwendet Python das Präfix r, um anzuzeigen, dass nicht alle Zeichen in der Zeichenfolge maskiert werden.

(3) re.search(pattern, „ROAD“) Das re-Modul verfügt über zwei Parameter, einer ist ein regulärer Ausdruck und der andere ist eine Zeichenfolge Dieses übereinstimmende Objekt kann in einer Methode beschrieben werden und None wird zurückgegeben, wenn keine Übereinstimmung gefunden wird.

3 Lose reguläre Ausdrücke

Die oben genannten sind alle Ausdrücke vom Typ „kompakt“, die schwer zu lesen sind. Auch wenn die Bedeutung des Ausdrucks jetzt klar ist, gibt es keine Garantie dafür Ich kann es auch ein paar Monate später noch lesen. Daher ermöglicht Python Benutzern die Verwendung sogenannter loser regulärer Ausdrücke, um die Anforderungen von Inline-Dokumenten zu erfüllen. Es gibt zwei Hauptunterschiede zu allgemeinen Ausdrücken in den folgenden zwei Aspekten:

Leerzeichen ignorieren. Leerzeichen, Tabulatoren und Wagenrückläufe stimmen nicht mit sich selbst überein (wenn Sie ein Leerzeichen in einem losen regulären Ausdruck abgleichen möchten, müssen Sie es nicht durch Einfügen eines Backslash-Zeichens davor maskieren)

Ignorieren Kommentare. Kommentare beginnen wie normaler Python-Code mit dem #-Symbol und enden am Ende der Zeile.

#松散带有内联注释的正则表达式
    pattern = """
    ^   # begin of string
    M{0,3} # 0 to 3 M
    (CM|CD|D?C{0,3}) #CM or CD or D or D 0 to 3 C
    $   #end of string
    """
    print(re.search(pattern,"MCM",re.VERBOSE)) #<_sre.SRE_Match object at 0x021BAF60>
    print(re.search(pattern,"M99",re.VERBOSE)) #None

(1) Bei der Verwendung loser regulärer Ausdrücke ist das Wichtigste: Es muss ein zusätzlicher Parameter re.VERBOSE übergeben werden, der eine Konstante des re-Moduls ist und die Übereinstimmung als regulär markiert Ausdruck ist ein loser regulärer Ausdruck. Musterräume und Kommentare werden ignoriert, haben aber gleichzeitig eine bessere Lesbarkeit.

4 Fallstudien: Parsing-Telefonnummern

müssen mit den folgenden Telefonnummern übereinstimmen:

800-555-1212

800 555 1212

800.555.1212

(800)555-1212

1-800-555-1212

800-555-1212-1234

800 -555-1212x1234

800-555-1212 ext.1234

work 1-(800) 555,1212 #1234

Es gibt viele Formate, was wir brauchen Wir wissen, dass 800 die Ortsvorwahl ist, die Amtsleitungsnummer ist 555 und die anderen Ziffern in der Telefonnummer sind 1212. Für diejenigen mit Durchwahlnummern müssen wir wissen, dass die Durchwahlnummer 1234 ist

phonePattern = re.compile(r'''
    # don't match beginging of string
(\d{3}) # 3 digits
\D*     #any number of non-digits
(\d{3}) # 3 digits
\D*     #any number of non-digits
(\d{4}) # 4 digits
\D*     #any number of non-digits
(\d*)   #any number of digits
''',re.VERBOSE)
print(phonePattern.search('work 1-(800)555.1212 #1234').groups()) #('800', '555', '1212', '1234')

print(phonePattern.search('work 1-( 800)555.1212 #1234').groups()) #('800', '555', '1212', '1234')

(1) Ein loser regulärer Ausdruck ist wie oben: Zuerst werden 3 numerische Ortsvorwahlen gefunden (beginnt nicht unbedingt mit dem ersten Zeichen, daher wird ^ nicht verwendet), dann wird eine beliebige Anzahl nicht numerischer Zeichen gefunden, dann werden 3 numerische Amtsleitungsnummern gefunden, dann werden Übereinstimmungen gefunden eine beliebige Anzahl nicht numerischer Zeichen, dann eine Übereinstimmung mit 4 Eine numerische Nummer, dann eine beliebige Anzahl nicht numerischer Zeichen, dann eine beliebige Anzahl numerischer Durchwahlnummern und dann die Gruppenfunktion zum Gruppieren verwenden, um die richtige Telefonnummer zu erhalten.