Espressione regolare di Python

In questo argomento, impareremo espressioni regolari di Python.

Definizione: Espressioni regolari, a volte chiamate re o regex o regexp, sono sequenze di caratteri per abbinare i modelli in testo/stringa. Python ha un modulo RE integrato per eseguire questo.

Gli usi comuni di un'espressione regolare sono:

1. Cerca una stringa (cerca e trova)
2. Trova tutta la stringa corrispondente (Findall)
3. Stringa divisa in sottostringa (divisa)
4. Sostituire parte di una stringa (sub)

Un'espressione regolare è una combinazione di alfabeti, metacharacters. Quindi sono disponibili seguendo i metacharacter.

• \ Questo viene usato per far cadere/ignorare il significato speciale del carattere
• [] Questo indica una classe di personaggi Ex: [A-Z], [A-Za-Z0-9]
• ^ Questo corrisponde all'inizio del testo
• $ Questo corrisponde alla fine del testo
• . Questo corrisponde a qualsiasi personaggio tranne Newline
• ? Abbinare zero o un evento.
• | Significa o (abbinare con uno qualsiasi dei personaggi separati da esso.
• * Qualsiasi numero di eventi (inclusi 0 occorrenze)
• + Uno o più occorrenze
• Indica diverse occorrenze di una re precedente da abbinare.
• () Racchiudere un gruppo di regexp

Se utilizziamo la backslash '\', indica varie sequenze. Voglio usare la retroscena senza il suo significato speciale usare '\\'.

• \ D corrisponde a qualsiasi cifra decimale, questo è lo stesso della classe set [0-9]
• \ D corrisponde a qualsiasi carattere non cifra
• \ s corrisponde a qualsiasi personaggio di spazi bianchi.
• \ S corrisponde a qualsiasi carattere non Whitespace
• \ W abbina qualsiasi carattere alfanumerico; Questo è lo stesso di una classe [A-Za-Z0-9_].
• \ W abbina qualsiasi carattere non alfanumerico.

Il seguente metodo disponibile nel modulo RE:

Re.ricerca() :

Questo metodo restituisce la parte corrispondente della stringa e si ferma dopo la prima partita. Quindi questo può essere usato per testare un'espressione piuttosto che per estrarre dati.

Sintassi: Rif.Search (pattern, string)
Valore di ritorno:
Nessuno : Il modello non corrisponde
Corda : pattern abbinato

Ex: In questo esempio cercherà mese e data

importazione re
regexp = r "([a-za-z]+) (\ d+)"
match = re.Search (Regexp, "Mio figlio è il 20 luglio")
Se abbina != Nessuno:
Stampa ("Match at Index %S, %s" %(Match.start (), corrispondenza.fine ()))#Questo fornisce indice della stringa abbinata
Stampa ("Full Match: % S" % (Match.gruppo (0)))
Stampa ("Month: % S" % (Match.gruppo 1)))
Stampa ("Day: % S" % (Match.gruppo (2)))
altro:
Stampa ("Il modello regex dato non corrisponde")

Rif.incontro() :

Questo metodo cerca e restituisce la prima partita. Questo controlla la corrispondenza solo all'inizio della stringa.

Sintassi: Rif.match (pattern, string)
Valore di ritorno:
Nessuno: il modello non corrisponde
String: pattern abbinato

Es: questo esempio per mostrare il pattern abbinato all'inizio della stringa

importazione re
regexp = r "([a-za-z]+) (\ d+)"
match = re.Match (Regexp, "20 luglio")
Se match == nessuno:
Stampa ("non una data valida")
altro:
Print ("Dato String: % S" % (Match.gruppo()))
Stampa ("Month: % S" % (Match.gruppo 1)))
Stampa ("Day: % S" % (Match.gruppo (2)))

Es: mostrare il modello non abbinato all'inizio

importazione re
match = re.Match (Regexp, "Mio figlio è il 20 luglio")
Se match == nessuno:
Stampa ("non una data valida")
altro:
Print ("Dato String: % S" % (Match.gruppo()))
Stampa ("Month: % S" % (Match.gruppo 1)))
Stampa ("Day: % S" % (Match.gruppo (2)))

Rif.trova tutto() :

Questo metodo restituisce tutte le partite di pattern in una stringa. La stringa viene cercata dall'inizio alla fine e le partite vengono restituite nell'ordine trovato.

Sintassi : Rif.findall (pattern, string)
Valore di ritorno
String vuota ([)]: il modello non corrisponde
Elenco della stringa: pattern abbinato

Es: espressione regolare per trovare cifre

importazione re
String = "" "Bangalore Pincode è 560066 e
Gulbarga Pincode è 585101 ""
regexp = '\ d+'
match = re.findall (regexp, string)
Stampa (Match)

Es: trova il numero di cellulare (numero esatto a 10 cifre) dal testo dato

importazione re
String = "" "Bangalore Office Numero 1234567891,
Il mio numero è 8884278690, contatto di emergenza 3456789123
Numero non valido 898883456 ""
regexp = '\ d 10'#questa espressione regolare per abbinare il numero esatto di 10 cifre
match = re.findall (regexp, string)
Stampa (Match)

Rif.compilare():

Le espressioni regolari sono compilate in oggetti pattern e possono essere utilizzate sui metodi. Esempio di ricerca di corrispondenze di pattern, sostituzioni di stringa.

Ex:

importazione re
e = re.Compile ('[a-e]')
Stampa (e.findall ("I nato alle 11 a.M. il 20 luglio 1989 "))
e = re.Compile ('\ d') # \ d equivale a [0-9].
Stampa (e.findall ("I nato alle 11 a.M. il 20 luglio 1989 "))
p = re.Compile ('\ d+')#Gruppo di una o più cifre
Stampa (p.findall ("I nato alle 11 a.M. il 20 luglio 1989 "))

Rif.diviso():

Stringa divisa in base alle occorrenze di uno schema. Se trovato modello, i restanti caratteri della stringa vengono restituiti come parte dell'elenco risultante. Possiamo specificare la divisione massima per una determinata stringa.

Sintassi - Rif.split (pattern, stringa, maxsplit = 0)
Valori di ritorno:
Elenco vuoto ([]): il modello non corrisponde
Elenco della stringa: pattern abbinato

Ex:

importazione re
# '\ W+' corrisponde a caratteri non alfanumerici o gruppo di personaggi
# diviso dopo aver trovato ',' o spazio bianco "
Stampa (Re.split ('\ w+', 'buono, meglio, migliore'))
Stampa (Re.split ('\ w+', "libri del libro"))
# Qui ':', ',', 'non sono alfanumerici dove si verifica la scissione
Stampa (Re.Split ('\ w+', 'nato il 20 luglio 1989, alle 11:00'))
# '\ d+' indica caratteri numerici o gruppi di caratteri
# Spliting si verifica a "20", "1989", "11", "00"
Stampa (Re.Split ('\ d+', 'nato il 20 luglio 1989, alle 11:00'))
# SPAZIONE MASSIMO specificata come 1
Stampa (Re.Split ('\ d+', nato il 20 luglio 1989, alle 11:00
Am ', maxsplit = 1))

Rif.sub():

Qui il significato "sub" è una sottostringa. In questa funzione, l'espressione regolare data (parametro pattern) è abbinata nella stringa data (parametro stringa); Se viene trovata la sottostringa, viene sostituita da un parametro di replica.
Qui nel conteggio, specificare il numero di volte in cui il regex viene sostituito.
Qui possiamo specificare il flag Regex (Ex: Re. Ignorecase)

Sintassi:- Rif.sub (pattern, repl, string, count = 0, flags = 0)
Valore di ritorno:
Restituisce una nuova stringa dopo aver sostituito un modello altro
Restituisce la stessa stringa

Ex:

importazione re
# Ex: Pattern 'lly' corrisponde alla stringa a "correttamente" e "delly"
Stampa (Re.sub ('lly', '#$', 'appuntamento medico prenotato con successo in delly'))
# Ex: Case hasbeen ignorato, usando la flag, 'lly' WI si abbina due volte con la stringa
# Dopo la corrispondenza, "lly" è sostituito da "*" in "correttamente" e "delly".
Stampa (Re.sub ('lly', '#$', 'appuntamento medico prenotato con successo in delly', flags = re.Ignorecase))
# Ex: Case Senhity, 'lly' non sarà riapplicazione.
Stampa (Re.sub ('lly', '#$', 'appuntamento medico prenotato con successo in delly'))
# Ex: come conteggio = 1, la sostituzione massima dei tempi è 1
Stampa (Re.sub ('lly', '#$', 'appuntamento medico prenotato correttamente in delly', count = 1, flags = re.Ignorecase))

Rif.subn ():

funzionalità subn () uguale a sub () in tutti i modi; L'unica differenza è fornire l'output. Restituisce una tupla che contiene un conteggio di un totale di sostituzione e nuova stringa.
Sintassi:- Rif.subn (pattern, repl, string, count = 0, flags = 0)

Ex:

importazione re
Stampa (Re.subn ('lly',#$ ',' appuntamento medico prenotato con successo in delly '))
t = re.Subn ('lly',#$ ',' appuntamento medico prenotato con successo in delly ', flags = re.Ignorecase)
stampa (t)
Stampa (len (t))
# Questo darà lo stesso output di sub ()
print (t [0])

Rif.fuga() :

Questo restituisce la stringa con backslash '\' prima di ogni carattere non alfanumerico. Questo è utile se vogliamo abbinare una stringa letterale arbitraria che può avere metacharacter di espressione regolare.
Sintassi:- Rif.Escape (String)
Ex:

importazione re
# sotto il caso ha solo ", non è alfanumerico
Stampa (Re.Escape ("appuntamento medico prenotato con successo alle 13:00")
# sotto il caso ha, ", caret '^', '-', '[]', '\' non sono alfanumerici
Stampa (Re.Escape ("Ha chiesto cos'è questo [0-9], ho detto \ t ^classe numerica")

Conclusione:

L'articolo ha coperto le cose necessarie per comprendere l'espressione regolare in qualsiasi applicazione. Abbiamo imparato vari metodi e meta personaggi presenti in Python Regexp usando esempi.