Python RegEx

Dans ce didacticiel, vous découvrirez les expressions régulières (RegEx) et utiliserez le module re de Python pour travailler avec RegEx (à l'aide d'exemples).

Un Reg ular Ex pression (RegEx) est une séquence de caractères qui définit un modèle de recherche. Par exemple,

^a...s$

Le code ci-dessus définit un modèle RegEx. Le modèle est :toute chaîne de cinq lettres commençant par a et se terminant par s .

Un modèle défini à l'aide de RegEx peut être utilisé pour correspondre à une chaîne.

Expression	Chaîne	Correspondance ?
`^a...s$`	`abs`	Aucune correspondance
	`alias`	Correspondance
	`abyss`	Correspondance
	`Alias`	Aucune correspondance
	`An abacus`	Aucune correspondance

Python a un module nommé re travailler avec RegEx. Voici un exemple :

import re

pattern = '^a...s$'
test_string = 'abyss'
result = re.match(pattern, test_string)

if result:
  print("Search successful.")
else:
  print("Search unsuccessful.")

Ici, nous avons utilisé re.match() fonction pour rechercher motif dans la test_string . La méthode renvoie un objet match si la recherche aboutit. Sinon, il renvoie None .

Il existe plusieurs autres fonctions définies dans le re module pour travailler avec RegEx. Avant d'explorer cela, découvrons les expressions régulières elles-mêmes.

Si vous connaissez déjà les bases de RegEx, passez à Python RegEx.

Spécifier le modèle à l'aide de RegEx

Pour spécifier des expressions régulières, des métacaractères sont utilisés. Dans l'exemple ci-dessus, ^ et $ sont des métacaractères.

Métacaractères

Les métacaractères sont des caractères qui sont interprétés d'une manière spéciale par un moteur RegEx. Voici une liste de métacaractères :

[] . ^ $ * + ? {} () \ |

[] - Crochets

Les crochets spécifient un ensemble de caractères que vous souhaitez faire correspondre.

Expression	Chaîne	Correspondance ?
`[abc]`	`a`	1 match
	`ac`	2 matchs
	`Hey Jude`	Aucune correspondance
	`abc de ca`	5 matchs

Ici, [abc] correspondra si la chaîne que vous essayez de faire correspondre contient l'un des a , b ou c .

Vous pouvez également spécifier une plage de caractères en utilisant - entre crochets.

[a-e] est identique à [abcde] .
[1-4] est identique à [1234] .
[0-39] est identique à [01239] .

Vous pouvez compléter (inverser) le jeu de caractères en utilisant le caret ^ symbole au début d'un crochet.

[^abc] signifie n'importe quel caractère sauf a ou b ou c .
[^0-9] désigne tout caractère non numérique.

. - Période

Un point correspond à n'importe quel caractère unique (sauf saut de ligne '\n' ).

Expression	Chaîne	Correspondance ?
`..`	`a`	Aucune correspondance
	`ac`	1 match
	`acd`	1 match
	`acde`	2 correspondances (contient 4 caractères)

^ - Caret

Le symbole caret ^ est utilisé pour vérifier si une chaîne commence par un certain caractère.

Expression	Chaîne	Correspondance ?
`^a`	`a`	1 match
	`abc`	1 match
	`bac`	Aucune correspondance
`^ab`	`abc`	1 match
`^ab`	`acb`	Aucune correspondance (commence par `a` mais non suivi de `b` )

$ - Dollar

Le symbole dollar $ est utilisé pour vérifier si une chaîne se termine par un certain caractère.

Expression	Chaîne	Correspondance ?
`a$`	`a`	1 match
	`formula`	1 match
	`cab`	Aucune correspondance

* - Étoile

Le symbole étoile * correspond à zéro ou plusieurs occurrences du motif qui lui reste.

Expression	Chaîne	Correspondance ?
`ma*n`	`mn`	1 match
	`man`	1 match
	`maaan`	1 match
	`main`	Pas de correspondance (`a` n'est pas suivi de `n` )
	`woman`	1 match

+ - Plus

Le symbole plus + correspond à une ou plusieurs occurrences du motif qui lui reste.

Expression	Chaîne	Correspondance ?
`ma+n`	`mn`	Pas de correspondance (pas de `a` caractère)
	`man`	1 match
	`maaan`	1 match
	`main`	Pas de correspondance (a n'est pas suivi de n)
	`woman`	1 match

? - Point d'interrogation

Le symbole du point d'interrogation ? correspond à zéro ou une occurrence du motif qui lui reste.

Expression	Chaîne	Correspondance ?
`ma?n`	`mn`	1 match
	`man`	1 match
	`maaan`	Pas de correspondance (plus d'un `a` caractère)
	`main`	Pas de correspondance (a n'est pas suivi de n)
	`woman`	1 match

{} - Bretelles

Considérez ce code :{n,m} . Cela signifie au moins n , et au plus m répétitions du motif qui lui reste.

Expression	Chaîne	Correspondance ?
`a{2,3}`	`abc dat`	Aucune correspondance
	`abc daat`	1 correspondance (à `daat` )
	`aabc daaat`	2 correspondances (à `aabc` et `daaat` )
	`aabc daaaat`	2 correspondances (à `aabc` et `daaaat` )

Essayons un autre exemple. Cette RegEx [0-9]{2, 4} correspond à au moins 2 chiffres mais pas plus de 4 chiffres

Expression	Chaîne	Correspondance ?
`[0-9]{2,4}`	`ab123csde`	1 correspondance (correspondance à `ab123csde` )
	`12 and 345673`	3 correspondances (`12` , `3456` , `73` )
	`1 and 2`	Aucune correspondance

| - Alternance

Barre verticale | est utilisé pour l'alternance (or opérateur).

Expression	Chaîne	Correspondance ?
`a\|b`	`cde`	Aucune correspondance
	`ade`	1 correspondance (correspondance à `ade` )
	`acdbea`	3 correspondances (à `acdbea` )

Ici, a|b correspond à n'importe quelle chaîne contenant soit a ou b

() - Groupe

Parenthèses () est utilisé pour regrouper des sous-modèles. Par exemple, (a|b|c)xz correspond à n'importe quelle chaîne qui correspond soit à a ou b ou c suivi de xz

Expression	Chaîne	Correspondance ?
`(a\|b\|c)xz`	`ab xz`	Aucune correspondance
	`abxz`	1 correspondance (correspondance à `abxz` )
	`axz cabxz`	2 correspondances (à `axzbc cabxz` )

\ - Barre oblique inversée

Jeu \ est utilisé pour échapper divers caractères, y compris tous les métacaractères. Par exemple,

\$a correspond si une chaîne contient $ suivi de a . Ici, $ n'est pas interprété par un moteur RegEx d'une manière particulière.

Si vous ne savez pas si un caractère a une signification particulière ou non, vous pouvez mettre \ devant elle. Cela garantit que le personnage n'est pas traité d'une manière spéciale.

Séquences spéciales

Des séquences spéciales facilitent l'écriture des modèles couramment utilisés. Voici une liste de séquences spéciales :

\A - Correspond si les caractères spécifiés sont au début d'une chaîne.

Expression	Chaîne	Correspondance ?
`\Athe`	`the sun`	Correspondance
`\Athe`	`In the sun`	Aucune correspondance

\b - Correspond si les caractères spécifiés sont au début ou à la fin d'un mot.

Expression	Chaîne	Correspondance ?
`\bfoo`	`football`	Correspondance
	`a football`	Correspondance
	`afootball`	Aucune correspondance
`foo\b`	`the foo`	Correspondance
	`the afoo test`	Correspondance
	`the afootest`	Aucune correspondance

\B - En face de \b . Correspond si les caractères spécifiés ne sont pas au début ou à la fin d'un mot.

Expression	Chaîne	Correspondance ?
`\Bfoo`	`football`	Aucune correspondance
	`a football`	Aucune correspondance
	`afootball`	Correspondance
`foo\B`	`the foo`	Aucune correspondance
	`the afoo test`	Aucune correspondance
	`the afootest`	Correspondance

\d - Correspond à n'importe quel chiffre décimal. Équivalent à [0-9]

Expression	Chaîne	Correspondance ?
`\d`	`12abc3`	3 correspondances (à `12abc3` )
`\d`	`Python`	Aucune correspondance

\D - Correspond à n'importe quel chiffre non décimal. Équivalent à [^0-9]

Expression	Chaîne	Correspondance ?
`\D`	`1ab34"50`	3 correspondances (à `1ab34"50` )
`\D`	`1345`	Aucune correspondance

\s - Correspond là où une chaîne contient n'importe quel caractère d'espacement. Équivalent à [ \t\n\r\f\v] .

Expression	Chaîne	Correspondance ?
`\s`	`Python RegEx`	1 match
`\s`	`PythonRegEx`	Aucune correspondance

\S - Correspond là où une chaîne contient n'importe quel caractère autre qu'un espace. Équivalent à [^ \t\n\r\f\v] .

Expression	Chaîne	Correspondance ?
`\S`	`a b`	2 correspondances (à `a b` )
`\S`		Aucune correspondance

\w - Correspond à n'importe quel caractère alphanumérique (chiffres et alphabets). Équivalent à [a-zA-Z0-9_] . Au fait, soulignez _ est également considéré comme un caractère alphanumérique.

Expression	Chaîne	Correspondance ?
`\w`	`12&": ;c`	3 correspondances (à `12&": ;c` )
`\w`	`%"> !`	Aucune correspondance

\W - Correspond à tout caractère non alphanumérique. Équivalent à [^a-zA-Z0-9_]

Expression	Chaîne	Correspondance ?
`\W`	`1a2%c`	1 correspondance (à `1a2%c` )
`\W`	`Python`	Aucune correspondance

\Z - Correspond si les caractères spécifiés sont à la fin d'une chaîne.

Expression	Chaîne	Correspondance ?
`Python\Z`	`I like Python`	1 match
	`I like Python Programming`	Aucune correspondance
	`Python is fun.`	Aucune correspondance

Astuce : Pour créer et tester des expressions régulières, vous pouvez utiliser des outils de test RegEx tels que regex101. Cet outil vous aide non seulement à créer des expressions régulières, mais il vous aide également à l'apprendre.

Maintenant que vous comprenez les bases de RegEx, voyons comment utiliser RegEx dans votre code Python.

Python RegEx

Python a un module nommé re pour travailler avec des expressions régulières. Pour l'utiliser, nous devons importer le module.

import re

Le module définit plusieurs fonctions et constantes pour travailler avec RegEx.

re.findall()

Le re.findall() renvoie une liste de chaînes contenant toutes les correspondances.

Exemple 1 :re.findall()


# Program to extract numbers from a string

import re

string = 'hello 12 hi 89. Howdy 34'
pattern = '\d+'

result = re.findall(pattern, string) 
print(result)

# Output: ['12', '89', '34']

Si le motif n'est pas trouvé, re.findall() renvoie une liste vide.

re.split()

Le re.split divise la chaîne où il y a une correspondance et renvoie une liste de chaînes où les divisions se sont produites.

Exemple 2 :re.split()


import re

string = 'Twelve:12 Eighty nine:89.'
pattern = '\d+'

result = re.split(pattern, string) 
print(result)

# Output: ['Twelve:', ' Eighty nine:', '.']

Si le motif n'est pas trouvé, re.split() renvoie une liste contenant la chaîne d'origine.

Vous pouvez passer maxsplit argument du re.split() méthode. C'est le nombre maximum de divisions qui se produiront.


import re

string = 'Twelve:12 Eighty nine:89 Nine:9.'
pattern = '\d+'

# maxsplit = 1
# split only at the first occurrence
result = re.split(pattern, string, 1) 
print(result)

# Output: ['Twelve:', ' Eighty nine:89 Nine:9.']

Au fait, la valeur par défaut de maxsplit est 0 ; c'est-à-dire tous les fractionnements possibles.

re.sub()

La syntaxe de re.sub() est :

re.sub(pattern, replace, string)

La méthode renvoie une chaîne où les occurrences correspondantes sont remplacées par le contenu de replace variables.

Exemple 3 :re.sub()


# Program to remove all whitespaces
import re

# multiline string
string = 'abc 12\
de 23 \n f45 6'

# matches all whitespace characters
pattern = '\s+'

# empty string
replace = ''

new_string = re.sub(pattern, replace, string) 
print(new_string)

# Output: abc12de23f456

Si le modèle n'est pas trouvé, re.sub() renvoie la chaîne d'origine.

Vous pouvez passer compter comme quatrième paramètre du re.sub() méthode. S'il est omis, le résultat est 0. Cela remplacera toutes les occurrences.


import re

# multiline string
string = 'abc 12\
de 23 \n f45 6'

# matches all whitespace characters
pattern = '\s+'
replace = ''

new_string = re.sub(r'\s+', replace, string, 1) 
print(new_string)

# Output:
# abc12de 23
# f45 6

re.subn()

Le re.subn() est similaire à re.sub() sauf qu'il renvoie un tuple de 2 éléments contenant la nouvelle chaîne et le nombre de substitutions effectuées.

Exemple 4 :re.subn()


# Program to remove all whitespaces
import re

# multiline string
string = 'abc 12\
de 23 \n f45 6'

# matches all whitespace characters
pattern = '\s+'

# empty string
replace = ''

new_string = re.subn(pattern, replace, string) 
print(new_string)

# Output: ('abc12de23f456', 4)

re.search()

Le re.search() La méthode prend deux arguments :un motif et une chaîne. La méthode recherche le premier emplacement où le modèle RegEx produit une correspondance avec la chaîne.

Si la recherche aboutit, re.search() renvoie un objet match ; sinon, il renvoie None .

match = re.search(pattern, str)

Exemple 5 :re.search()


import re

string = "Python is fun"

# check if 'Python' is at the beginning
match = re.search('\APython', string)

if match:
  print("pattern found inside the string")
else:
  print("pattern not found")  

# Output: pattern found inside the string

Ici, correspond contient un objet match.

Faire correspondre l'objet

Vous pouvez obtenir les méthodes et les attributs d'un objet match en utilisant la fonction dir().

Certaines des méthodes et attributs couramment utilisés des objets match sont :

match.group()

Le group() renvoie la partie de la chaîne où il y a une correspondance.

Exemple 6 :faire correspondre un objet


import re

string = '39801 356, 2102 1111'

# Three digit number followed by space followed by two digit number
pattern = '(\d{3}) (\d{2})'

# match variable contains a Match object.
match = re.search(pattern, string) 

if match:
  print(match.group())
else:
  print("pattern not found")

# Output: 801 35

Ici, correspond la variable contient un objet match.

Notre modèle (\d{3}) (\d{2}) a deux sous-groupes (\d{3}) et (\d{2}) . Vous pouvez obtenir la partie de la chaîne de ces sous-groupes entre parenthèses. Voici comment :

>>> match.group(1)
'801'

>>> match.group(2)
'35'
>>> match.group(1, 2)
('801', '35')

>>> match.groups()
('801', '35')

match.start(), match.end() et match.span()

Le start() La fonction renvoie l'index du début de la sous-chaîne correspondante. De même, end() renvoie l'index de fin de la sous-chaîne correspondante.

>>> match.start()
2
>>> match.end()
8

Le span() La fonction renvoie un tuple contenant l'index de début et de fin de la partie correspondante.

>>> match.span()
(2, 8)

match.re et match.string

Le re L'attribut d'un objet correspondant renvoie un objet d'expression régulière. De même, string L'attribut renvoie la chaîne passée.

>>> match.re
re.compile('(\\d{3}) (\\d{2})')

>>> match.string
'39801 356, 2102 1111'

Nous avons couvert toutes les méthodes couramment utilisées définies dans le re module. Si vous voulez en savoir plus, visitez Python 3 re module.

Utiliser le préfixe r avant RegEx

Quand r ou R préfixe est utilisé avant une expression régulière, cela signifie une chaîne brute. Par exemple, '\n' est une nouvelle ligne alors que r'\n' signifie deux caractères :une barre oblique inverse \ suivi de n .

Jeu \ est utilisé pour échapper divers caractères, y compris tous les métacaractères. Cependant, en utilisant r le préfixe fait \ traiter comme un personnage normal.

Exemple 7 :Chaîne brute utilisant le préfixe r


import re

string = '\n and \r are escape sequences.'

result = re.findall(r'[\n\r]', string) 
print(result)

# Output: ['\n', '\r']

Décorateur Python @property Date-heure Python

Python