Introduction détaillée à l'expression régulière du module python

1. Brève introduction

L'expression régulière est un petit langage de programmation hautement spécialisé, pas un python C'est un langage de base et important fait partie de nombreux langages de programmation. En python, il est principalement implémenté via le module re.

Les modèles d'expressions régulières sont compilés dans une série de bytecodes puis exécutés par un moteur de correspondance écrit en C. Alors, quels sont les scénarios d’utilisation courants des expressions régulières ?

Par exemple, spécifiez une règle pour l'ensemble de chaînes correspondant auquel vous souhaitez faire correspondre

L'ensemble de chaînes peut inclure des adresses e-mail, des adresses Internet et des numéros de téléphone ; , ou Ce sont des ensembles de chaînes personnalisés en fonction des besoins ;

Bien sûr, vous pouvez également juger si un ensemble de chaînes est conforme aux règles de correspondance que nous définissons

Trouver la partie de la chaîne qui ; correspond à la règle ;

Une série de traitements de texte tels que la modification et la coupure;

......

2. Symboles et caractères spéciaux (Métacaractères )

Voici quelques métacaractères courants, qui confèrent aux expressions régulières une fonctionnalité et une flexibilité puissantes. Le tableau 2-1 répertorie les symboles et caractères les plus courants.

3. Expressions régulières

1. Utilisez la fonction compile()pour compiler des expressions régulières

En raison de Le code Python est finalement traduit en bytecode puis exécuté sur l'interpréteur. Par conséquent, il sera plus pratique de précompiler certaines expressions régulières souvent utilisées dans notre code. La plupart des fonctions du

module re ont les mêmes noms et ont les mêmes fonctionnalités que les méthodes de l'objet d'expression régulière compilé et des objets correspondants réguliers.

Exemple :

>>> import re
>>> r1 = r'bugs'                            # 字符串前加"r"反斜杠就不会被任何特殊方式处理，这是个习惯，虽然这里没用到
>>> re.findall(r1, 'bugsbunny')             # 直接利用re模块进行解释性地匹配
['bugs']                         
>>>
>>> r2 = re.compile(r1)                     # 如果r1这个匹配规则你会经常用到，为了提高效率，那就进行预编译吧
>>> r2                                      # 编译后的正则对象
<_sre.SRE_Pattern object at 0x7f5d7db99bb0>
>>>
>>> r2.findall(&#39;bugsbunny&#39;)                 # 访问对象的findall方法得到的匹配结果与上面是一致的
[&#39;bugs&#39;]                                    # 所以说，re模块中的大多数函数和已经编译的正则表达式对象和正则匹配对象的方法同名并且具有相同的功能

La fonction re.compile() accepte également les paramètres d'indicateur facultatifs, qui sont couramment utilisés pour implémenter différentes fonctions spéciales et changements de syntaxe. Ces indicateurs sont également disponibles comme arguments pour la plupart des fonctions du module re. Ces drapeaux peuvent être combinés à l'aide de l'opérateur (|).

Exemple :

>>> import re
>>> r1 = r'bugs'
>>> r2 = re.compile(r1,re.I)  # 这里选择的是忽略大小写的标志，完整的是re.IGNORECASE，这里简写re.I
>>> r2.findall('BugsBunny')
['Bugs']
 
# re.S 使.匹配换行符在内的所有字符
# re.M 多行匹配，英雄^和$
# re,X 用来使正则匹配模式组织得更加清晰

Pour une liste complète des paramètres et de l'utilisation du drapeau, veuillez vous référer aux documents officiels concernés.

2. Utilisation d'expressions régulières

le module re fournit une interface pour un moteur d'expressions régulières Voici quelques fonctions et méthodes couramment utilisées.

Objet Match et méthodes group() et groups()

Lorsqu'il s'agit d'expressions régulières, en plus de l'objet expression régulière, il existe un autre type d'objet : l'objet match. Ce sont les objets renvoyés par un appel réussi à match() ou search(). Les objets Match ont deux méthodes principales : group() et groups().

group() renvoie soit l'intégralité de l'objet de correspondance, soit un sous-groupe spécifique sur demande. groups() renvoie simplement un tuple contenant uniquement ou tous les sous-groupes. Si aucun sous-groupe n'est requis, groups renvoie un tuple vide tandis que group() renvoie toujours la correspondance entière. Quelques exemples de fonctions ci-dessous illustrent cette méthode.

Utilisez la méthode match() pour faire correspondre une chaîne

La fonction match() correspond au motif depuis le début de la chaîne. Si la correspondance réussit, un objet de correspondance est renvoyé ; si la correspondance échoue, None est renvoyé et la méthode group() de l'objet de correspondance peut être utilisée pour afficher la correspondance réussie.

Un exemple est le suivant :

>>> m = re.match('bugs', 'bugsbunny')     # 模式匹配字符串
>>> if m is not None:                     # 如果匹配成功，就输出匹配内容
...     m.group()
...
'bugs'
>>> m
<_sre.SRE_Match object at 0x7f5d7da1f168> # 确认返回的匹配对象

Utilisez search() pour trouver un modèle dans une chaîne

search()的工作方式与match()完全一致，不同之处在于search()是对给定正则表达式模式搜索第一次出现的匹配情况。简单来说，就是在任意位置符合都能匹配成功，不仅仅是字符串的起始部分，这就是与match()函数的区别，用脚指头想想search()方法使用的范围更多更广。

示例：

>>> m = re.search('bugs', 'hello bugsbunny')
>>> if m is not None:
...     m.group()
...
'bugs'

 使用findall()和finditer()查找每一次出现的位置

findall()是用来查找字符串中所有（非重复）出现的正则表达式模式，并返回一个匹配列表；finditer()与findall()不同的地方是返回一个迭代器，对于每一次匹配，迭代器都返回一个匹配对象。

>>> m = re.findall('bugs', 'bugsbunnybugs')
>>> m
['bugs', 'bugs']
>>> m = re.finditer('bugs', 'bugsbunnybugs')
>>> m.next()                                   # 迭代器用next()方法返回一个匹配对象
<_sre.SRE_Match object at 0x7f5d7da71a58>      # 匹配用group()方法显示出来
>>> m.next().group()
&#39;bugs&#39;

 使用sub()和subn()搜索与替换

都是将某字符串中所有匹配正则表达式的部分进行某种形式的替换。sub()返回一个用来替换的字符串，可以定义替换次数，默认替换所有出现的位置。subn()和sub()一样，但subn()还返回一个表示替换的总是，替换后的字符串和表示替换总数一起作为一个拥有两个元素的元组返回。

示例：

>>> r = 'a.b'
>>> m = 'acb abc aab aac'
>>> re.sub(r,'hello',m)
'hello abc hello aac'
>>> re.subn(r,'hello',m)
('hello abc hello aac', 2)

字符串也有一个replace()方法，当遇到一些模糊搜索替换的时候，就需要更为灵活的sub()方法了。

使用split()分割字符串

同样的，字符串中也有split()，但它也不能处理正则表达式匹配的分割。在re模块中，分居正则表达式的模式分隔符，split函数将字符串分割为列表，然后返回成功匹配的列表。

示例：

>>> s = '1+2-3*4'
>>> re.split(r'[\+\-\*]',s)
['1', '2', '3', '4']

分组

有时在匹配的时候我们只想提取一些想要的信息或者对提取的信息作一个分类，这时就需要对正则匹配模式进行分组，只需要加上()即可。

示例：

>>> m = re.match('(\w{3})-(\d{3})','abc-123')
>>> m.group()       # 完整匹配                        
'abc-123'
>>> m.group(1)      # 子组1
'abc'
>>> m.group(2)      # 子组2
'123'
>>> m.groups()      # 全部子组
('abc', '123')

由以上的例子可以看出，group()通常用于以普通方式显示所有的匹配部分，但也能用于获取各个匹配的子组。可以使用groups()方法来获取一个包含所有匹配字符串的元组。

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!