espressioni regolari python3

Le espressioni regolari sono una sequenza di caratteri speciali, può aiutare a controllare facilmente se una stringa corrisponde a un modello.

Python ri incrementi di moduli a partire dalla versione 1.5, modello di espressione regolare che fornisce Perl-stile.

re modulo permette linguaggio Python ha tutte le caratteristiche di espressioni regolari.

funzione di compilazione per generare un oggetto espressione regolare da una stringa modello e le bandiere dei parametri opzionali. Questo oggetto ha una serie di metodi per la corrispondenza di espressioni regolari e sostituzione.

re modulo fornisce anche un metodo coerente con queste caratteristiche funzioni che utilizzano un modello di stringa come primo parametro.

Questa sezione presenta le funzioni di elaborazione espressioni regolari comuni Python.

---

funzione re.match

re.match cerca di abbinare un modello dalla posizione di partenza della stringa, se non il corrispondente posizione di partenza è di successo, match () restituisce nessuno.

sintassi della funzione:

re.match(pattern, string, flags=0)

Parametri di funzione:

parametri	descrizione
modello	Partita espressione regolare
stringa	La stringa da abbinare.
bandiere	Bandiera, l'abbinamento espressione regolare viene usato per controllare, come ad esempio: se il multi-linea di maiuscole e minuscole partite, e così via.

Il successo metodo match re.match restituisce un oggetto corrispondenza, altrimenti nessuno.

Siamo in grado di utilizzare la funzione di gruppo (num) o gruppi () per ottenere gli oggetti corrispondenti corrispondono espressioni.

Corrispondenti metodi di un oggetto	descrizione
gruppo (num = 0)	L'intero string matching espressione, di gruppo () può immettere più di un numero di gruppo, nel qual caso verrà restituito un valore corrispondente a quei gruppi di tuple.
gruppi ()	Esso restituisce una tupla di tutti i gruppi della stringa, da 1 al numero contenuto nel gruppo.

Esempio 1:

#!/usr/bin/python
# -*- coding: UTF-8 -*- 

import re
print(re.match('www', 'www.w3big.com').span())  # 在起始位置匹配
print(re.match('com', 'www.w3big.com'))         # 不在起始位置匹配

Eseguire l'uscita precedente esempio è il seguente:

(0, 3)
None

Esempio 2:

#!/usr/bin/python3
import re

line = "Cats are smarter than dogs"

matchObj = re.match( r'(.*) are (.*?) .*', line, re.M|re.I)

if matchObj:
   print ("matchObj.group() : ", matchObj.group())
   print ("matchObj.group(1) : ", matchObj.group(1))
   print ("matchObj.group(2) : ", matchObj.group(2))
else:
   print ("No match!!")

I risultati degli esempi di cui sopra sono i seguenti:

matchObj.group() :  Cats are smarter than dogs
matchObj.group(1) :  Cats
matchObj.group(2) :  smarter

---

metodo re.search

re.search scansionare l'intera stringa e restituisce il primo successo di abbinamento.

sintassi della funzione:

re.search(pattern, string, flags=0)

Parametri di funzione:

parametri	descrizione
modello	Partita espressione regolare
stringa	La stringa da abbinare.
bandiere	Bandiera, l'abbinamento espressione regolare viene usato per controllare, come ad esempio: se il multi-linea di maiuscole e minuscole partite, e così via.

Il successo metodo match re.search restituisce un oggetto corrispondenza, altrimenti nessuno.

Siamo in grado di utilizzare la funzione di gruppo (num) o gruppi () per ottenere gli oggetti corrispondenti corrispondono espressioni.

Corrispondenti metodi di un oggetto	descrizione
gruppo (num = 0)	L'intero string matching espressione, di gruppo () può immettere più di un numero di gruppo, nel qual caso verrà restituito un valore corrispondente a quei gruppi di tuple.
gruppi ()	Esso restituisce una tupla di tutti i gruppi della stringa, da 1 al numero contenuto nel gruppo.

Esempio 1:

#!/usr/bin/python3

import re

print(re.search('www', 'www.w3big.com').span())  # 在起始位置匹配
print(re.search('com', 'www.w3big.com').span())         # 不在起始位置匹配

Eseguire l'uscita precedente esempio è il seguente:

(0, 3)
(11, 14)

Esempio 2:

#!/usr/bin/python3

import re

line = "Cats are smarter than dogs";

searchObj = re.search( r'(.*) are (.*?) .*', line, re.M|re.I)

if searchObj:
   print ("searchObj.group() : ", searchObj.group())
   print ("searchObj.group(1) : ", searchObj.group(1))
   print ("searchObj.group(2) : ", searchObj.group(2))
else:
   print ("Nothing found!!")

I risultati degli esempi di cui sopra sono i seguenti:

searchObj.group() :  Cats are smarter than dogs
searchObj.group(1) :  Cats
searchObj.group(2) :  smarter

---

La re.match differenza e re.search

re.match corrisponde solo l'inizio della stringa, se l'inizio della stringa non soddisfa l'espressione regolare, il match fallisce, la funzione restituisce None, e re.search corrisponde l'intera stringa, fino a quando non trova una corrispondenza.

esempio:

#!/usr/bin/python3

import re

line = "Cats are smarter than dogs";

matchObj = re.match( r'dogs', line, re.M|re.I)
if matchObj:
   print ("match --> matchObj.group() : ", matchObj.group())
else:
   print ("No match!!")

matchObj = re.search( r'dogs', line, re.M|re.I)
if matchObj:
   print ("search --> matchObj.group() : ", matchObj.group())
else:
   print ("No match!!")

Esempi dei risultati di cui sopra sono i seguenti:

No match!!
search --> matchObj.group() :  dogs

---

Ricerca e sostituzione

modulo re di Python fornisce re.sub per la partita stringa di sostituzione.

sintassi:

re.sub(pattern, repl, string, count=0)

La stringa restituita è la stringa con i più a sinistra partite RE non si ripeterà per sostituire. Se il modello non viene trovato, i personaggi saranno restituiti invariati.

conteggio parametro opzionale è il numero massimo di volte una sostituzione pattern matching; conteggio deve essere un numero intero non negativo. Il valore di default è 0 mezzo per sostituire tutte le occorrenze.

esempio:

#!/usr/bin/python3
import re

phone = "2004-959-559 # 这是一个电话号码"

# 删除注释
num = re.sub(r'#.*$', "", phone)
print ("电话号码 : ", num)

# 移除非数字的内容
num = re.sub(r'\D', "", phone)
print ("电话号码 : ", num)

I risultati degli esempi di cui sopra sono i seguenti:

电话号码 :  2004-959-559 
电话号码 :  2004959559

---

Regex modificatore - bandiera opzionale

Le espressioni regolari possono contenere bandiere modificatori opzionali per il controllo della modalità di partita. Modifier è specificato come una bandiera opzionale. (|) Per specificare più flag che può essere OR bit a bit attraverso. Come re.I | re.M è impostato su bandiere I e M:

modificatori	descrizione
re.I	In modo che la corrispondenza non è case sensitive
re.L	Fare di identificazione la localizzazione di corrispondenza (locale-aware)
re.M	Multi-corrispondenza nelle linee ^ e $
re.S	So., a capo inclusi Match tutti i personaggi
re.U	Secondo risolvere Unicode caratteri set di caratteri. Questo flag colpisce \ w, \ W, \ b, \ B.
re.X	Questo flag dando formato più flessibile, in modo che si scrivere espressioni regolari più facile da capire.

---

modello di espressione regolare

stringa modello utilizzando una sintassi speciale per indicare una espressione regolare:

Lettere e numeri stessi. Un modello di espressione regolare di lettere e numeri corrisponde alla stessa stringa.

La maggior parte delle lettere e numeri avranno un significato diverso quando preceduto da un backslash.

La punteggiatura è sfuggito solo quando la partita stessa, o rappresentano un significato speciale.

Backslash stesso ha bisogno di usare la fuga backslash.

Dal momento che le espressioni regolari di solito contengono barre inverse, quindi è meglio utilizzare la stringa originale a rappresentarli. gli elementi dello schema (come r '/ t', equivalente a '// t') corrisponde ai caratteri speciali corrispondenti.

La seguente tabella elenca gli elementi specifici di sintassi delle espressioni regolari. Se i modelli di utilizzo, fornendo argomento flags opzionale, il significato di alcuni elementi del modello cambierà.

modo	descrizione
^	Corrisponde all'inizio della stringa
$	Corrisponde alla fine della stringa.
.	Corrisponde a qualsiasi carattere tranne a capo, quando si specifica re.DOTALL bandiera, è possibile abbinare qualsiasi carattere includa una nuova riga.
[...]	E 'utilizzato per rappresentare un gruppo di personaggi, elencati separatamente: [amk] match' a ',' M 'o' k '
[^ ...]	Non [] caratteri: [^ abc] partite in aggiunta ai caratteri a, b, c.
re *	0 o più di corrispondenza espressione.
re +	Uno o più delle espressioni corrispondenti.
re?	Partita 0 o 1 con le espressioni regolari precedenti per definire i segmenti, modo non avido
re {n}
ri {n,}	Una corrispondenza esatta di espressione n precedente.
re {n, m}	Partita n a m volte con le espressioni regolari precedenti per definire i segmenti, così avido
A | B	Una partita o B
(Re)	G partita espressione all'interno delle parentesi, rappresenta anche un gruppo
(? Imx)	espressione regolare si compone di tre bandiere opzionali: i, m, o x. Interessa solo l'area tra parentesi.
(? -imx)	Le espressioni regolari Chiudere i, m, o x bandiera opzionale. Interessa solo l'area tra parentesi.
(: Re)	Simili (...), ma non rappresenta un gruppo
(Imx :? Re)	Io uso tra parentesi, m, o x bandiera opzionale
(-imx :? Re)	Non utilizzare i, m tra parentesi, o X bandiera opzionale
(? # ...)	Nota.
(? = Re)	Inoltra sicuro delimitatore. Se l'espressione regolare contenuta, qui rappresentata da ... partite con successo nella posizione corrente, e non riesce altrimenti. Tuttavia, una volta che l'espressione contenuta è stata provata, il motore di corrispondenza non avanza, mentre il resto del modello è nemmeno provato delimitatore destra.
(?! Re)	delimitatore negazione avanti. E delimitatore certamente contrario, di successo quando l'espressione contenuta non corrisponde alla posizione corrente nella stringa
(?> Re)	pattern matching indipendente, eliminando backtracking.
\ W	partita alfanumerico
\ W	Partita non alfanumerico
\ S	Corrisponde a qualsiasi carattere di spazio, equivalente a [\ t \ n \ r \ f].
\ S	Corrisponde a qualsiasi carattere non vuota
\ D	Corrisponde a qualsiasi numero che è equivalente a [0-9].
\ D	Corrisponde a qualsiasi non numerico
\ A	Corrisponde all'inizio della stringa
\ Z	alla fine della stringa Match, se esiste a capo, poco prima della fine della stringa in modo che corrisponda a capo. c
\ Z	alla fine della stringa Partita
\ G	Match completato ultima posizione.
\ B	Corrisponde a un limite di parola, cioè, si riferisce alla posizione e gli spazi tra le parole. Ad esempio, 'er \ b' può corrispondere al "mai" nel 'er', ma non può corrispondere al "verbo" nel 'er'.
\ B	Partita di non limite di parola. 'Er \ B' può corrispondere al "verbo" nel 'er', ma non può corrispondere "mai" nel 'er'.
\ N, \ t, e simili.	Corrisponde a una nuova riga. Corrisponde a un carattere di tabulazione. aspettare
\ 1 ... \ 9	Abbinamento sub-espressione pacchetto n-esimo.
\ 10	Partita la prima n pacchetti subespressione se si tratta dopo una partita. Altrimenti, l'espressione si riferisce al codice di carattere ottale.

---

Esempi di espressioni regolari

le partite di carattere

Esempi	descrizione
pitone	Corrispondenza "python".

Classi di caratteri

Esempi	descrizione
[PP] ython	Corrispondenza "Python" o "pitone"
strofinare [voi]	Match "ruby" o "rube"
[Aeiou]	Qualsiasi una delle lettere in parentesi corrispondenza
[0-9]	Corrisponde a qualsiasi cifra. Simile a [0123456789]
[AZ]	Corrisponde a qualsiasi lettere minuscole
[AZ]	Corrisponde a qualsiasi maiuscolo
[A-Za-Z0-9]	Corrisponde a qualsiasi lettere e numeri
[^ Aeiou]	Oltre a tutti i caratteri diversi da lettere aeiou
[^ 0-9]	Abbinamento carattere tranne figure

Classi di caratteri speciali

Esempi	descrizione
.	Corrisponde a qualsiasi carattere singolo tranne "\ n" è. Per far corrispondere tra cui '\ n', tra cui tutti i caratteri, come l'uso di '[. \ N]' modalità.
\ D	Corrisponde a un carattere cifre. Equivalente a [0-9].
\ D	Corrispondono a un caratteri non numerici. E 'equivalente a [^ 0-9].
\ S	Corrisponde a qualsiasi carattere di spazio bianco, compresi gli spazi, tabulazioni, interruzioni di pagina e così via. È equivalente a [\ f \ n \ r \ t \ v].
\ S	Corrisponde a qualsiasi carattere non di spaziatura. È equivalente a [^ \ f \ n \ r \ t \ v].
\ W	Ogni carattere di parola compreso sottolineatura. E 'equivalente a' [A-Za-z0-9_] '.
\ W	Corrisponde a qualsiasi carattere non-parola. E 'equivalente a' [^ A-Za-z0-9_] '.