Regulärer Ausdruck (regulär)

Regular , Um reguläre Ausdrücke zu verwenden, müssen Sie das re-Modul (Abkürzung für „regular“) in Python importieren. Wir wissen, dass Zeichenfolgen manchmal viele Informationen enthalten, die wir extrahieren möchten. Die Beherrschung dieser Methoden zur Verarbeitung von Zeichenfolgen kann viele unserer Vorgänge erleichtern.

Regulärer Ausdruck (regulär), eine Methode zur Verarbeitung von Zeichenfolgen. http://www.cnblogs.com/alex3714/articles/5169958.html

Regulärer Ausdruck ist eine häufig verwendete Methode, da die Dateiverarbeitung in Python sehr verbreitet ist und die Datei enthält Wenn Sie Zeichenfolgen verarbeiten möchten, müssen Sie reguläre Ausdrücke verwenden. Daher müssen Sie reguläre Ausdrücke beherrschen. Werfen wir einen Blick auf die in regulären Ausdrücken enthaltenen Methoden:

(1) match(pattern, string, flags=0)

def match(pattern, string, flags=0):
　　"""Versuchen Sie, das Muster anzuwenden der Anfang der Zeichenfolge, gibt
ein Übereinstimmungsobjekt zurück oder „Keine“, wenn keine Übereinstimmung gefunden wurde >
Kommentar von oben: Versuchen Sie, das Muster am Anfang der Zeichenfolge anzuwenden und ein Übereinstimmungsobjekt zurückzugeben, oder „Keine“, wenn keine Übereinstimmung gefunden wurde. Beginnen Sie mit der Suche am Anfang der Zeichenfolge und geben Sie ein Übereinstimmungsobjekt zurück, wenn es nicht gefunden wird, geben Sie ein None zurück. Wichtige Punkte: (1) Beginnen Sie mit der Suche von vorne. (2) Geben Sie „Keine“ zurück, wenn nicht gefunden.

Schauen wir uns ein paar Beispiele an:

import re String =

"abcdef"

m = re.match("abc",string) (1) Vergleichen Sie „abc“ und sehen Sie, was das zurückgegebene Ergebnis ist

print(m)

print(m .group())
n = re.match("abcf",string)
print(n) (2) Wenn die Zeichenfolge nicht in der Liste gesucht wird
l = re.match(
"bcd",string) (3) String-Suche in der Mitte der Liste
print(l)

<_sre.SRE_Match object; span=(0, 3), match='abc'> （1）
abc （2）
Keine

Wie aus dem obigen Ausgabeergebnis (1) ersichtlich ist, gibt die Verwendung von match() zum Abgleichen ein Übereinstimmungsobjektobjekt zurück. Wenn Sie es in eine sichtbare Situation konvertieren möchten, müssen Sie zum Konvertieren group() verwenden (2) Wie hier gezeigt: Wenn der passende reguläre Ausdruck nicht in der Zeichenfolge enthalten ist, wird „None“ (3) vom Anfang der Zeichenfolge an zurückgegeben und kann nur vom Anfang an ausgeführt werden die Zeichenfolge Match (4) wie gezeigt.

(2) fullmatch(pattern, string, flags=0)

def fullmatch(pattern, string, flags=0):
ein Übereinstimmungsobjekt, oder None, wenn keine Übereinstimmung gefunden wurde."""
　　 return _compile(pattern, flags).fullmatch(string)
Kommentar von oben: Versuchen Sie, das anzuwenden Muster für die gesamte Zeichenfolge, Rückgabe eines Übereinstimmungsobjekts oder „Keine“, wenn keine Übereinstimmung gefunden wurde...

(3) search(pattern,string,flags )

def search(pattern , string, flags=

0): 　　"""Durchsuchen Sie die Zeichenfolge und suchen Sie für eine Übereinstimmung mit dem Muster wird
　　　ein Übereinstimmungsobjekt zurückgegeben, oder „Keine“, wenn keine Übereinstimmung gefunden wurde.                                                                                                        Muster, gibt ein Übereinstimmungsobjekt zurück oder „Keine“, wenn keine Übereinstimmung gefunden wurde, und gibt das Übereinstimmungsobjekt zurück, wenn es nicht gefunden wird.

Wichtige Punkte: (1) Suche von jeder Position in der Mitte der Zeichenfolge aus, im Gegensatz zu match(), das von Anfang an sucht. (2) Wenn die Suche nicht gefunden werden kann, Keine wird zurückgegeben "a",string) (1) Übereinstimmung aus der Mitte print(m)
print(m.group()) n = re.search("N", Zeichenfolge) (2) Die Situation, die nicht abgeglichen werden kann Drucken (n)

Die laufenden Ergebnisse lauten wie folgt:

<_sre.SRE_Match object; ; (1)
a                                                                                                                                                                                                                                             >

Wie aus dem obigen Ergebnis (1) ersichtlich ist, kann search(pattern, string, flag=0) von jeder Position in der Mitte aus übereinstimmen, was den Anwendungsbereich erweitert, im Gegensatz zu match(), das dies kann Nur von Anfang an übereinstimmen. Wenn eine Übereinstimmung vorliegt, wird ein match_object-Objekt zurückgegeben. (2) Wenn Sie ein match_object-Objekt anzeigen möchten, müssen Sie die Methode „group()“ verwenden .

(4) sub(pattern,repl,string,count=0,flags=0)

 def sub(pattern, repl, string, count=0, flags=0):
"""Gibt die Zeichenfolge zurück, die durch Ersetzen der nicht überlappenden
　　linken Vorkommen des Musters in der Zeichenfolge durch den
　　　Ersatz repl erhalten wird. repl kann entweder eine Zeichenfolge oder ein aufrufbarer Wert sein;
　　bei einer Zeichenfolge wird der Backslash maskiert darin verarbeitet werden. Wenn es
ein Callable ist, wird ihm das Match-Objekt übergeben und muss
eine zu verwendende Ersatzzeichenfolge zurückgeben 　　return _compile(pattern, flags).sub(repl, string, count)
sub(pattern,repl,string,count=0, Flags = 0) Suchen und Ersetzen, dh zuerst feststellen, ob das Muster in der Zeichenfolge enthalten ist; und wie viele Übereinstimmungen. Ein Beispiel lautet wie folgt:

import re String =

"ddafsadadfadfafdafdadfasfdafafda"

m = re.sub(
" a","A",string)
#Gibt nicht die Anzahl der Ersetzungen an (1)
　print(m)n = re.sub("a",
"A",string,2)
#
Geben Sie die Anzahl der Ersetzungen an (2) print(n) l = re.sub("F",
"B",string) #
Kann nicht übereinstimmen (3)
print(l)
Die laufenden Ergebnisse sind wie folgt:

ddAfsAdAdfAdfAfdAfdAdfAsfdAfAfdA — (1) ddAfsAdadfadfaf dafdadfasfdafafda - - (2) ddafsadadfadfafdafdadfasfdafafda --(3)

Der obige Code (1) gibt nicht die Anzahl der Übereinstimmungen an, daher ist die Standardeinstellung, alle zu treffen die Anzahl der Übereinstimmungen, dann wird nur die angegebene Anzahl abgeglichen; wenn das reguläre Muster, das bei (3) abgeglichen werden soll, nicht in der Zeichenfolge enthalten ist, wird die ursprüngliche Zeichenfolge zurückgegeben.

    重点：(1)可以指定匹配个数,不指定匹配所有；（2）如果匹配不到会返回原来的字符串；

    （5）subn(pattern,repl,string,count=0,flags=0)

    def subn(pattern, repl , string, count=0, flags=0):
   　　　　"""Gibt ein 2-Tupel zurück, das (new_string, number) enthält.
   　　　　new_string ist der erhaltene String durch Ersetzen der am weitesten links stehenden
   　　　　nicht überlappenden Vorkommen des Musters in der Quelle
   　　　　String durch die Ersatz-Repl.   Zahl ist die Anzahl der vorgenommenen
   　　　　kann entweder eine Zeichenfolge oder ein
   　　　　aufrufbares Objekt sein; wenn es sich um eine Zeichenfolge handelt, werden die darin enthaltenen Backslash-Escapezeichen verarbeitet.
   　　　　Wenn es sich um ein aufrufbares Objekt handelt, muss es das Übereinstimmungsobjekt übergeben und muss
Gibt eine zu verwendende Ersatzzeichenfolge zurück >
    上面注释Gib ein 2-Tupel zurück, das(new_string,number) enthält import re　　string = "ddafsadadfadfafdafdadfasfdafafda"

　　m = re.subn(

"a","A",string)     #

全部替换的情况 （

1）
　　print(m)
　　n = re.subn("a",
"A",string,3) #替换部分     （2）
　　print(n)
　　l = re.subn(
"F", "A",string)      #指定替换的字符串不存在   （3）　　print(l)



   A', 11)     （ 1） ('ddafsadadfAfdafdadfasfdafafda', 3) （2） ('ddafsadadfaFdafdadfasfdafda', 0) （3）

Wie aus der Ausgabe des obigen Codes ersichtlich ist, ist sub() und subn(pattern,repl,string,count=0,flags=0) der passende Effekt der beiden gleich, aber die zurückgegebenen Ergebnisse sind nur unterschiedlich. sub() gibt immer noch eine Zeichenfolge zurück, während subn() ein Tupel zurückgibt, das zum Speichern der neuen Zeichenfolge nach dem regulären Ausdruck und der Anzahl der Ersetzungen verwendet wird.

(6) split(pattern,string,maxsplit=0,flags=0)

def split(pattern, string, maxsplit=0, flags=0):
　　"""Teilt die Quellzeichenfolge nach den Vorkommen des Musters auf,
                                                                                                                                                                                                  Rückgabe einer Liste mit den resultierenden Teilzeichenfolgen. 🎜>
Liste. Wenn maxsplit ungleich Null ist, treten höchstens maxsplit-Splits auf,
und der Rest der Zeichenfolge wird als letztes Element zurückgegeben
der Liste. 🎜> 　　
return _compile(pattern, flags).split(string, maxsplit)

split(pattern, string, maxsplit=0, flags=0) ist die Aufteilung eines Strings Die Zeichenfolge wird gemäß einem bestimmten regulären Anforderungsmuster aufgeteilt. Die Rückgabe einer Liste mit den resultierenden Teilzeichenfolgen bedeutet, die Zeichenfolge auf irgendeine Weise aufzuteilen und in eine Liste einzufügen. Ein Beispiel lautet wie folgt:

 

import re　string = "ddafsadadfadfafdafdadfasfdafafda"

　m = re.split(" a",string)
#Split string (
1)
print(m) n = re.split(" a",string,3)
#Geben Sie die Anzahl der Teilungen an

　print(n)　l = re.split(" F",string ) #
Die geteilte Zeichenfolge existiert nicht in der Liste
print(l)

Die Laufergebnisse lauten wie folgt:

['dd', 'fs', 'd', 'df', 'df', 'fd', 'fd', 'df', ' sfd', 'f', 'fd ', ''] （1）

['dd', 'fs', 'd', 'dfadfafdafdadfasfdafafda'] （2）['ddafsadadfadfafdafdadfasfdafafda'] (3 )

Aus (1) geht hervor, dass das folgende Element ein „“ ist, wenn der Anfang oder das Ende der Zeichenfolge die zu teilende Zeichenfolge enthält. Bei (2) können wir die Häufigkeit angeben zu teilen; (3) ) Wenn die zu teilende Zeichenfolge nicht in der Liste vorhanden ist, fügen Sie die ursprüngliche Zeichenfolge in die Liste ein.

(7) findall(pattern,string,flags=)

def findall(pattern, string, flags=0):
　　"""Gibt eine Liste aller nicht überlappenden Übereinstimmungen in der Zeichenfolge zurück.

Wenn eine oder mehrere einfangende Gruppen im Muster vorhanden sind, geben Sie
eine Liste von Gruppen zurück; dies ist eine Liste von Tupeln, wenn das Muster
mehr als eine Gruppe hat.

Leere Übereinstimmungen werden in das Ergebnis einbezogen > findall(pattern, string, flags=) gibt eine Liste mit allen passenden Elementen zurück. In einer Liste gespeichert. Ein Beispiel lautet wie folgt:

import re String = "dd12a32d46465fad1648fa1564fda127fd11ad30fa02sfd58afafda" m =. re.findall (" [a-z]",string) #Buchstaben abgleichen, alle Buchstaben abgleichen, Liste zurückgeben (1)　print(m)n = re.findall(" [0 -9]",string) #Alle Zahlen abgleichen und eine Liste zurückgeben (2)

print(n)l = re.findall(
"[ABC]" , Zeichenfolge) #s s s (3)
PRINT (L)






Die laufenden Ergebnisse lauten wie folgt:
['d', 'd', 'a', 'd', 'f', 'a' , 'd ', 'f', 'a', 'f', 'd', 'a', 'f', 'd', 'a', 'd', 'f', 'a', 's', 'f', 'd', 'a', 'f', 'a', 'f', 'd', 'a'] (1) ['1', '2', '3' , '2', '4', '6', '4', '6', '5', '1', '6', '4', '8', '1', '5', ' 6“, „4“, „1“, „2“, „7“, „1“, „1“, „3“, „0“, „0“, „2“, „5“, „8“ ] (2) [] (3) Das obige Codelaufergebnis (1) stimmt mit allen Zeichenfolgen überein, eine einzelne Übereinstimmung (2 Wenn die Zahl in Wenn die Zeichenfolge bei (3) übereinstimmt, wird eine Liste zurückgegeben. Wenn die Übereinstimmung bei (3) nicht vorhanden ist, wird eine leere Liste zurückgegeben.

Wichtige Punkte: (1) Gibt eine leere Liste zurück, wenn keine Übereinstimmung gefunden wird. (2) Wenn die Anzahl der Übereinstimmungen nicht angegeben ist, wird nur eine einzige Übereinstimmung erstellt.

    （8）finditer(pattern,string,flags=0)

    def finditer(pattern , string, flags=0):
   　　　　"""Gib einen Iterator über alle nicht überlappenden Übereinstimmungen in der
   　　　　Zeichenfolge zurück.  Für jede Übereinstimmung gibt der Iterator ein Übereinstimmungsobjekt zurück.

   　　　　Leere Übereinstimmungen werden in das Ergebnis einbezogen
    finditer(pattern,string)查找模式，Gibt einen Iterator über alle nicht überlappenden Übereinstimmungen in der zurück string.Für jede Übereinstimmung gibt der Iterator ein Übereinstimmungsobjekt an.

    代码如下：

    import re　　string =

"dd12a32d46465fad1648fa1564fda127fd11ad30fa02sfd58afafda"

　　m =. re.finditer(
"[a-z]",string)
　　print(m)
　　n = re .finditer("AB",string)
　　print(n)


        运行结果如下:

               (1)　　           （2）

    从上面运行结果可以看出，finditer(pattern,string,flags=0)返回的是一个iterator对象。

    （9）compile(pattern,flags=0)

    def compile(pattern, flags= 0):

   　　　　

"Kompilieren Sie ein reguläres Ausdrucksmuster und geben Sie ein Musterobjekt zurück."    　　　　return _compile(pattern, flags)

    （10）pruge()

    def purge () 🎜>

    （11）template(pattern,flags=0)


    def template(pattern, flags =0):    　　　　

"Kompilieren Sie ein Vorlagenmuster und geben Sie ein Musterobjekt zurück"

   　　　　return _compile(pattern, flags|T)

    正则表达式:


    语法: 

　import re
　string = "dd12a32d46465fad1648fa1564fda127fd11ad30fa02sfd58afafda"

　p =.re.compile( "[a -z]+") # Verwenden Sie zuerst „compile(pattern)“, um
m = p.match(string) zu kompilieren. #Dann matchen Sie
print(m.group())

Die 2. und 3. Zeile oben können auch zu einer Zeile zusammengefasst werden, um zu schreiben:

    m = p.match("^[0-9]",'14534Abc'<code class="python plain"><span style="font-family: 宋体">)</span> )

Der Effekt ist derselbe, der Unterschied besteht darin, dass die erste Möglichkeit darin besteht, das abzugleichende Format im Voraus zu kompilieren (die Übereinstimmungsformel zu analysieren) , sodass Sie den Abgleich nicht kompilieren müssen Format beim erneuten Abgleich Format, die zweite Abkürzung ist, dass die passende Formel bei jedem Abgleich kompiliert werden muss. Wenn Sie daher alle Zeilen abgleichen müssen, die mit einer Zahl aus einer Datei mit 50.000 Zeilen beginnen, wird empfohlen, diese zu kompilieren Zuerst die reguläre Formel und dann „Match“ eingeben, dann geht es schneller.

Übereinstimmungsformat:

(1) ^ Entspricht dem Anfang der Zeichenfolge

 
import re String =
"dd12a32d41648f27fd11a0sfdda"
#^ entspricht dem Anfang der Zeichenfolge, jetzt verwenden wir search()
für eine Übereinstimmung mit , die mit einer Zahl beginnt m = re.search("^[0-9]",string) #
für eine Übereinstimmung mit einer Zeichenfolge, die mit beginnt eine Zahl ( 1)
print(m)
n = re.search("^[a-z]+",string) # Entspricht beginnenden Zeichenfolgen mit Buchstaben Start, wenn Sie von Anfang an übereinstimmen, gibt es keinen großen Unterschied zu search()
(2) 　print(n.group())

Das laufende Ergebnis lautet wie folgt:

Keine dd

In (1) oben verwenden wir ^ von der Zeichenfolge Der Abgleich beginnt am Anfang und ob der Anfang des Abgleichs eine Zahl ist, schlägt der Abgleich fehl und es wird „Keine“ zurückgegeben. Bei (2) beginnen wir mit dem Abgleich mit Buchstaben. Da der Anfang ein Buchstabe ist, ist die Übereinstimmung korrekt und es wird das richtige Ergebnis zurückgegeben. Aus dieser Sicht ähnelt ^ tatsächlich match() von Anfang an.

(2) $ Entspricht dem Ende der Zeichenfolge

 import re
String = "15111252598"

#^ entspricht dem Anfang der Zeichenfolge, jetzt verwenden wir search() to match
beginnend mit einer Zahl　m = re.match("^[0-9]{11}$",string)
print(m .group())

Die laufenden Ergebnisse sind wie folgt :

15111252598

re.match("^[0-9]{11}$",string) bedeutet, dass das Match beginnt mit einer Zahl und hat eine Länge von 11. Das Format endet mit einer Zahl

(3) Punkt (·) entspricht jedem Zeichen, außer Zeilenumbrüchen. Wenn die Markierung RE.Dotall angegeben ist, kann sie mit jedem in der Zeile enthaltenen Zeichen abgeglichen werden >n1252598"

　#Punkt (
·) entspricht allen Zeichen außer Zeilenumbrüchen　m = re.match (".,string)
#Der Punkt
(·) entspricht einem beliebigen Zeichen. Wenn die Zahl nicht angegeben ist, entspricht sie einem einzelnen (1)print( m.group())
n = re.match(".+",string) #.+ entspricht mehreren beliebigen Zeichen, außer Zeilenumbrüchen (2) 　print(n.group())




Die Laufergebnisse lauten wie folgt: 1 1511 Aus den Ergebnissen der obigen Codeausführung geht hervor, dass (1) der Punkt (·) mit jedem Zeichen übereinstimmt (2) mit mehreren Zeichen übereinstimmt, aber da die Zeichenfolge Leerzeichen enthält, ist das Ergebnis Nur der Inhalt vor dem Zeilenumbruchzeichen in der Zeichenfolge wird abgeglichen, der Inhalt danach wird nicht abgeglichen.

Wichtige Punkte: (1) Punkt (·) entspricht jedem Zeichen außer Zeilenumbrüchen. (2) .+ kann mit mehreren beliebigen Zeichen außer Zeilenumbrüchen übereinstimmen.

(4) [...] Beispielsweise entspricht [abc] „a“, „b“ oder „c“

[object] entspricht den in Klammern enthaltenen Zeichen. [A-Za-z0-9] bedeutet Übereinstimmung von A-Z oder a-z oder 0-9.

 import re
　string = "1511n125dadfadf2598"

　#[]match enthält Zeichen in Klammern
m = re.findall("[5fd]",string) # entspricht 5,f,d
im String print( m)

Die laufenden Ergebnisse lauten wie folgt:

['5', '5', 'd', 'd', 'f', 'd', 'f', '5 ' ]

Im obigen Code möchten wir 5, f, d in der Zeichenfolge abgleichen und eine Liste zurückgeben.

(5) [^...] [^abc] entspricht jedem Zeichen außer abc

import re
String = "1511n125dadfadf2598"

#[^] entspricht in Klammern eingeschlossenen Zeichen
m = re.findall("[^5fd]",string) # Entspricht den Zeichen in der Zeichenfolge außer 5, f, d
print(m)

Führen Sie Folgendes aus:

['1', '1', '1', 'n', '1', '2', 'a', 'a', '2', ' 9', '8']

Im obigen Code stimmen wir mit anderen Zeichen als 5, f, d überein. [^] stimmt mit Zeichen außerhalb von Klammern überein, mit anderen Zeichen als .

(6)* Entspricht 0 oder mehr Ausdrücken

import re
String = "1511n125dadfadf2598"

　 #* ist ein Ausdruck, der 0 oder mehr
　m = re entspricht. findall("d*",string) #Entspricht 0 oder mehr Zahlen
print(m)

Die Laufergebnisse sind wie folgt:

['1511', '', '125', '', '', '', '', '', '', '', ' 2598', '']

Aus den obigen Laufergebnissen geht hervor, dass (*) ein Ausdruck ist, der mit 0 oder mehr Zeichen übereinstimmt. Es ist ersichtlich, dass, wenn keine Übereinstimmung vorliegt, der Es wurde „Leer“ zurückgegeben, und die letzte zurückgegebene Position ist leer („“).

(7) + Entspricht einem oder mehreren Ausdrücken

import re
String = "1511n125dadfadf2598"

　#(+) entspricht 1 Ausdrücken von einem oder mehr
m = re.findall("d+",string) # Entspricht 1 oder mehr Zahlen
　print(m)

Führen Sie Folgendes aus:

['1511', '125', '2598']

Add (+) entspricht einem oder mehreren Ausdrücken. Das obige d+ entspricht einem oder mehreren numerischen Ausdrücken, mindestens einer Zahl.

(8)? Entspricht 0 oder 1 Ausdrücken, nicht gierige Art

import re
　string = "1511n125dadfadf2598"

　 #(?) stimmt mit 0 oder 1 Ausdrücke　m = re.findall(
"d?",string) #entspricht0 oder 1 Ausdrücke
print(m) 　

Die Laufergebnisse sind wie folgt:

['1', '5', '1', '1', '', '1', '2', '5', '' , '', '', ' ', '', '', '', '2', '5', '9', '8', '']

Das Fragezeichen (?) oben ist um mit 0 oder 1 Ausdrücken übereinzustimmen, und wenn keine Übereinstimmung gefunden wird, wird leer ("") zurückgegeben

(9){n} n-mal übereinstimmen, Anzahl der Übereinstimmungen für eine Zeichenfolge definieren

(10){n , m} Passt n an m-Ausdrücke an

(11) w Passt alphanumerische Zeichen an

w ist Um Buchstaben und Zahlen in der Zeichenfolge abzugleichen, lautet der Code wie folgt:

 import re
　 string = "1511n125dadfadf2598 „

　#(?) ist ein Ausdruck, der 0 oder 1
m entspricht = re.findall("w",string) #entspricht 0 oder 1 Ausdrücken
print( m)

Führen Sie Folgendes aus:

['1', '5' , '1 ', '1', '1', '2', '5', 'd', 'a', 'd', 'f', 'a', 'd', 'f', '2', '5', '9', '8']

Wie Sie dem obigen Code entnehmen können, wird w verwendet, um alphanumerische Zeichen in der Zeichenfolge abzugleichen. Wir verwenden reguläre Ausdrücke, um Buchstaben und Zahlen abzugleichen.

(12) W Der Großbuchstabe W wird verwendet, um Nicht-Buchstaben und Zahlen abzugleichen, was genau das Gegenteil des Kleinbuchstabens w

ist

Beispiele sind wie folgt:

import re
　 string = "1511n125dadfadf2598"

　#W wird verwendet, um Nicht-Buchstaben und Zahlen in der Zeichenfolge abzugleichen
　m = re.findall("W",string) #W wird verwendet, um Zeichen, die keine Buchstaben sind, und Zahlen in der Zeichenfolge
print(m)

Führen Sie Folgendes aus:

['n']

Im obigen Code wird W verwendet, um Nicht-Buchstaben und Zahlen abzugleichen. Das Ergebnis ist, dass Zeilenumbrüche abgeglichen werden.

(13)s Entspricht jedem Leerzeichen, äquivalent zu [ntf]

Beispiele sind wie folgt:

import re
String = "1511n125dt ardffadf2598"

　 #s wird verwendet, um alle Leerzeichen in der Zeichenfolge abzugleichen, entsprechend In [ntrf]
　m = re.findall("s",string) wird #s verwendet, um ein beliebiges Leerzeichen in der Zeichenfolge
print zu finden (m) 　

Führen Sie Folgendes aus:

['n', 't', 'r', 'x0c ']

Wie aus den obigen Code-Laufergebnissen hervorgeht: s wird verwendet, um jedes leere Zeichen abzugleichen. Wir haben das leere Zeichen

(14) S Entspricht jedem nicht leeren Zeichen

Beispiele sind wie folgt:

import re　string =
"1511n125dtardffadf2598"

　#S wird verwendet, um jedes nicht leere Zeichen zu finden　m = re.findall(
"S",string) #S ist Wird für jeden Tag verwendet. Nicht leere Zeichen
　print(m) ​ ​

​ Führen Sie Folgendes aus:

​ ['1', ' 5', '1', '1', '1', '2', '5', 'd', 'a', 'd', 'f', 'a', 'd', 'f' , '2', '5', '9', '8']

Wie aus dem obigen Code ersichtlich ist, ist S wird verwendet, um alle nicht leeren Zeichen abzugleichen. Im Ergebnis werden alle nicht leeren Zeichen gefunden.

(15)d Entspricht einer beliebigen Zahl, entsprechend [0-9]

( 16 ) D Entspricht allen Nicht-Zahlen

Zusammenfassung: findall() und split() generieren Listen, einer verwendet einen bestimmten Wert als Trennzeichen und der andere verwendet eine Suche nach allen Werten ​​in . Ganz im Gegenteil.

Das obige ist der detaillierte Inhalt vonRegulärer Ausdruck (regulär). Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!