Fonctions de traitement des expressions régulières couramment utilisées en Python

Répertoire d'articles

introduction

Le module re permet au langage Python d'avoir toutes les fonctions d'expression régulière

Utilisez la fonction d'objet de correspondance group (num) ou groups () pour obtenir l'expression correspondante.

group (num = 0) correspond à la chaîne d'expression entière, group () peut entrer plusieurs numéros de groupe à la fois, auquel cas il renverra un tuple contenant les valeurs correspondant à ces groupes.

groups () renvoie un tuple contenant toutes les chaînes de groupe, de 1 au numéro de groupe contenu.

1. fonction re.match

la description

re.match essaie de faire correspondre un modèle depuis le début de la chaîne. Si la correspondance échoue au début, match () n'en renvoie aucun

grammaire

re.match (modèle, chaîne, drapeaux = 0)

paramètre

pattern: la
chaîne d' expression régulière correspondante : la chaîne à mettre en correspondance
flags: flags, utilisés pour contrôler le mode de correspondance de l'expression régulière, tels que: sensible à la casse, correspondance multiligne

re J'ignore la casse

re.L signifie que le jeu de caractères spéciaux \ w, \ W, \ b, \ B, \ s, \ S dépend de l'environnement actuel

Mode multiligne re.M

re.S est tout caractère comprenant «.» et incluant le caractère de nouvelle ligne («.» n'inclut pas le caractère de nouvelle ligne)

re.U représente le jeu de caractères spéciaux \ w, \ W, \ b, \ B, \ d, \ D, \ s, \ S dépend de la base de données d'attributs de caractères Unicode

re.X Afin d'augmenter la lisibilité, ignorez les espaces et les commentaires après le '#'

revenir

Si la correspondance réussit, la méthode re.match renvoie un objet correspondant, sinon elle renvoie None.

Exemple

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

line = "Cats are smarter than dogs"
# .* 表示任意匹配除换行符（\n、\r）之外的任何单个或多个字符
# (.*?) 表示"非贪婪"模式，只保存第一个匹配到的子串
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!!")

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

2. méthode re.search

la description

re.search analyse toute la chaîne et renvoie la première correspondance réussie

grammaire

re.search (modèle, chaîne, drapeaux = 0)

paramètre

pattern: la
chaîne d' expression régulière correspondante : la chaîne à mettre en correspondance
flags: flags, utilisés pour contrôler le mode de correspondance de l'expression régulière, tels que: sensible à la casse, correspondance multiligne

re J'ignore la casse

re.L signifie que le jeu de caractères spéciaux \ w, \ W, \ b, \ B, \ s, \ S dépend de l'environnement actuel

Mode multiligne re.M

re.S est tout caractère comprenant «.» et incluant le caractère de nouvelle ligne («.» n'inclut pas le caractère de nouvelle ligne)

re.U représente le jeu de caractères spéciaux \ w, \ W, \ b, \ B, \ d, \ D, \ s, \ S dépend de la base de données d'attributs de caractères Unicode

re.X Afin d'augmenter la lisibilité, ignorez les espaces et les commentaires après le '#'

valeur de retour

Si la correspondance réussit, la méthode re.search renvoie un objet correspondant, sinon elle renvoie None

Exemple

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

(0, 3)
(11, 14)

import re

s = 'A23G4HFD567'

# (?P<value>\d+)分组匹配，表示命名一个value的组，匹配规则是匹配一个到多个数字
res = re.search('(?P<value>\d+)', s)
print(res.groupdict())
{
    
    'value': '23'}

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!!")

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

3. La différence entre re.match et re.search

la description

re.match ne correspond qu'au début de la chaîne, si la chaîne ne correspond pas à l'expression régulière au début, la correspondance échoue, la fonction renvoie None et re.search correspond à la chaîne entière jusqu'à ce qu'une correspondance soit trouvée

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!!")

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

4. re.sub

la description

re.sub est utilisé pour remplacer les correspondances dans une chaîne

grammaire

re.sub (modèle, répl, chaîne, nombre = 0, indicateurs = 0)

paramètre

Les trois premiers sont des paramètres obligatoires et les deux derniers sont des paramètres facultatifs.
pattern: La chaîne de motif dans le regular.
repl: La chaîne remplacée, qui peut également être une fonction.
string: La chaîne d'origine à rechercher et à remplacer.
count: le nombre maximum de remplacements après la correspondance du modèle, la valeur par défaut 0 signifie remplacer toutes les correspondances.
flags: Le mode de correspondance utilisé lors de la compilation, sous forme numérique.

re J'ignore la casse

re.L signifie que le jeu de caractères spéciaux \ w, \ W, \ b, \ B, \ s, \ S dépend de l'environnement actuel

Mode multiligne re.M

re.S est tout caractère comprenant «.» et incluant le caractère de nouvelle ligne («.» n'inclut pas le caractère de nouvelle ligne)

re.U représente le jeu de caractères spéciaux \ w, \ W, \ b, \ B, \ d, \ D, \ s, \ S dépend de la base de données d'attributs de caractères Unicode

re.X Afin d'augmenter la lisibilité, ignorez les espaces et les commentaires après le '#'

Exemple

import re
 
phone = "2004-959-559 # 这是一个电话号码"
 
# 删除注释
# .*$ 表示从字符串末尾开始任意匹配除换行符（\n、\r）之外的任何单个或多个字符
# 将其替换为空格
num = re.sub(r'#.*$', "", phone)
print ("电话号码 : ", num)
 
# 移除非数字的内容
# '\D'表示匹配任何非数字
num = re.sub(r'\D', "", phone)
print ("电话号码 : ", num)

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

Le paramètre repl est une fonction

import re
 
# 将匹配的数字乘于 2
def double(matched):
    value = int(matched.group('value'))
    return str(value * 2)
 
s = 'A23G4HFD567'
# (?P<value>\d+)表示命名一个名字为value的组，匹配规则符合后面的\d+
print(re.sub('(?P<value>\d+)', double, s))

A46G8HFD1134

Fonction 5.re.compile

la description

La fonction re.compile est utilisée pour compiler des expressions régulières afin de générer un objet d'expression régulière (Pattern) à utiliser par match () et search ().

grammaire

re.compile (modèle [, indicateurs])

paramètre

motif: Un
indicateur d' expression régulière sous la forme d'une chaîne est facultatif, indiquant le mode de correspondance, comme ignorer la casse, le mode multiligne, etc. Les paramètres spécifiques sont:

re J'ignore la casse

re.L signifie que le jeu de caractères spéciaux \ w, \ W, \ b, \ B, \ s, \ S dépend de l'environnement actuel

Mode multiligne re.M

re.S est tout caractère comprenant «.» et incluant le caractère de nouvelle ligne («.» n'inclut pas le caractère de nouvelle ligne)

re.U représente le jeu de caractères spéciaux \ w, \ W, \ b, \ B, \ d, \ D, \ s, \ S dépend de la base de données d'attributs de caractères Unicode

re.X Afin d'augmenter la lisibilité, ignorez les espaces et les commentaires après le '#'

Exemple

>>>import re
>>> pattern = re.compile(r'\d+')                    # 用于匹配至少一个数字
>>> m = pattern.match('one12twothree34four')        # 查找头部，没有匹配
>>> print( m )
None
>>> m = pattern.match('one12twothree34four', 2, 10) # 从'e'的位置开始匹配，没有匹配
>>> print( m )
None
>>> m = pattern.match('one12twothree34four', 3, 10) # 从'1'的位置开始匹配，正好匹配
>>> print( m )                                        # 返回一个 Match 对象
<_sre.SRE_Match object at 0x10a42aac0>
>>> m.group(0)   # 可省略 0
'12'
>>> m.start(0)   # 可省略 0
3
>>> m.end(0)     # 可省略 0
5
>>> m.span(0)    # 可省略 0
(3, 5)

>>>import re
>>> pattern = re.compile(r'([a-z]+) ([a-z]+)', re.I)   # re.I 表示忽略大小写
>>> m = pattern.match('Hello World Wide Web')
>>> print( m )                            # 匹配成功，返回一个 Match 对象
<_sre.SRE_Match object at 0x10bea83e8>
>>> m.group(0)                            # 返回匹配成功的整个子串
'Hello World'
>>> m.span(0)                             # 返回匹配成功的整个子串的索引
(0, 11)
>>> m.group(1)                            # 返回第一个分组匹配成功的子串
'Hello'
>>> m.span(1)                             # 返回第一个分组匹配成功的子串的索引
(0, 5)
>>> m.group(2)                            # 返回第二个分组匹配成功的子串
'World'
>>> m.span(2)                             # 返回第二个分组匹配成功的子串索引
(6, 11)
>>> m.groups()                            # 等价于 (m.group(1), m.group(2), ...)
('Hello', 'World')
>>> m.group(3)                            # 不存在第三个分组
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: no such group

Lorsque la correspondance est réussie, un objet Match est renvoyé, où:

La méthode group ([group1,…]) est utilisée pour obtenir une ou plusieurs chaînes de correspondance groupées. Lorsque vous souhaitez obtenir l'intégralité de la sous-chaîne correspondante, vous pouvez utiliser directement group () ou group (0);

La méthode start ([group]) est utilisée pour obtenir la position de départ de la sous-chaîne correspondante dans la chaîne entière (l'index du premier caractère de la sous-chaîne), et la valeur par défaut du paramètre est 0;

La méthode end ([group]) est utilisée pour obtenir la position de fin de la sous-chaîne correspondante dans la chaîne entière (l'index du dernier caractère de la sous-chaîne + 1), et la valeur par défaut du paramètre est 0;

La méthode span ([group]) renvoie (start (group), end (group)).

6.re.findall

la description

Recherchez toutes les sous-chaînes correspondant à l'expression régulière dans la chaîne et renvoyez une liste. Si aucune correspondance n'est trouvée, une liste vide est renvoyée.
Remarque: correspondance et recherche une fois, findall correspond à tout

grammaire

re.findall (motif, chaîne, drapeaux = 0)
或 motif.findall
(chaîne [, pos [, endpos]])

paramètre

motif Modèle assorti.
string La chaîne à rechercher.
pos est un paramètre facultatif qui spécifie la position de départ de la chaîne et la valeur par défaut est 0.
endpos est un paramètre facultatif qui spécifie la position de fin de la chaîne. La valeur par défaut est la longueur de la chaîne.

Exemple

import re
 
result1 = re.findall(r'\d+','runoob 123 google 456')
 
pattern = re.compile(r'\d+')   # 查找数字
result2 = pattern.findall('runoob 123 google 456')
result3 = pattern.findall('run88oob123google456', 0, 10)
 
print(result1)
print(result2)
print(result3)

['123', '456']
['123', '456']
['88', '12']

7.re.finditer

la description

Similaire à findall, recherchez toutes les sous-chaînes correspondant à l'expression régulière dans la chaîne et renvoyez-les sous forme d'itérateur

grammaire

re.finditer (modèle, chaîne, drapeaux = 0)

paramètre

motif Modèle assorti.
string La chaîne à rechercher.
flags est utilisé pour contrôler le mode de correspondance des expressions régulières, telles que: sensible à la casse, correspondance multiligne, etc.

re J'ignore la casse

re.L signifie que le jeu de caractères spéciaux \ w, \ W, \ b, \ B, \ s, \ S dépend de l'environnement actuel

Mode multiligne re.M

re.S est tout caractère comprenant «.» et incluant le caractère de nouvelle ligne («.» n'inclut pas le caractère de nouvelle ligne)

re.U représente le jeu de caractères spéciaux \ w, \ W, \ b, \ B, \ d, \ D, \ s, \ S dépend de la base de données d'attributs de caractères Unicode

re.X Afin d'augmenter la lisibilité, ignorez les espaces et les commentaires après le '#'

Exemple

import re
 
it = re.finditer(r"\d+","12a32bc43jf3") 
for match in it: 
    print (match.group() )
12 
32 
43 
3

8.re.split

la description

La méthode split divise la chaîne en fonction des sous-chaînes qui peuvent être mises en correspondance et renvoie la liste

grammaire

re.split (modèle, chaîne [, maxsplit = 0, flags = 0])

paramètre

motif Modèle assorti.
string La chaîne à rechercher.
maxsplit sépare le nombre de fois, maxsplit = 1 sépare une fois, la valeur par défaut est 0, il n'y a pas de limite au nombre de fois.
flags est utilisé pour contrôler le mode de correspondance des expressions régulières, telles que: sensible à la casse, correspondance multiligne, etc.

re J'ignore la casse

re.L signifie que le jeu de caractères spéciaux \ w, \ W, \ b, \ B, \ s, \ S dépend de l'environnement actuel

Mode multiligne re.M

re.S est tout caractère comprenant «.» et incluant le caractère de nouvelle ligne («.» n'inclut pas le caractère de nouvelle ligne)

re.U représente le jeu de caractères spéciaux \ w, \ W, \ b, \ B, \ d, \ D, \ s, \ S dépend de la base de données d'attributs de caractères Unicode

re.X Afin d'augmenter la lisibilité, ignorez les espaces et les commentaires après le '#'

Exemple

>>>import re
>>> re.split('\W+', 'runoob, runoob, runoob.')
['runoob', 'runoob', 'runoob', '']
>>> re.split('(\W+)', ' runoob, runoob, runoob.') 
['', ' ', 'runoob', ', ', 'runoob', ', ', 'runoob', '.', '']
>>> re.split('\W+', ' runoob, runoob, runoob.', 1) 
['', 'runoob, runoob, runoob.']
 
>>> re.split('a*', 'hello world')   # 对于一个找不到匹配的字符串而言，split 不会对其作出分割
['hello world']