Comment utiliser les expressions régulières en python

Les chaînes sont la structure de données la plus couramment utilisée en programmation, et la nécessité d'opérer sur des chaînes est presque partout. Par exemple, pour déterminer si une chaîne est une adresse e-mail légale, bien que vous puissiez extraire par programme les sous-chaînes avant et après @, puis déterminer s'il s'agit d'un mot et d'un nom de domaine, cela est non seulement gênant, mais également difficile à réutiliser. le code. Les expressions régulières sont une arme puissante pour faire correspondre des chaînes. Son idée de conception est d'utiliser un langage descriptif pour définir une règle pour une chaîne. Toute chaîne conforme à la règle est considérée comme « correspondante ».

Ainsi, la façon dont nous jugeons si une chaîne est un e-mail légal est la suivante :

Créez un e-mail correspondant à une expression régulière

Utilisez ceci ; expression régulière pour correspondre à l'entrée de l'utilisateur afin de déterminer si elle est légale.

Étant donné que les expressions régulières sont également représentées par des chaînes, nous devons d'abord comprendre comment utiliser les caractères pour décrire les caractères.

Dans les expressions régulières, si les caractères sont donnés directement, c'est une correspondance exacte. Utilisez d pour correspondre à un nombre et w pour correspondre à une lettre ou à un chiffre, donc :

'00d' peut correspondre à '007', mais pas

'ddd' peut correspondre ; '010';

'wwd' peut correspondre à 'py3';

peut correspondre à n'importe quel caractère, donc :

'py.' pyo', 'py!', etc.

Pour faire correspondre des caractères de longueur variable, dans les expressions régulières, utilisez * pour représenter n'importe quel nombre de caractères (y compris 0), + pour représenter au moins un caractère, ? pour représenter 0 ou 1 caractère, et { n} représente n caractères, et {n,m} représente n-m caractères :

Regardons un exemple complexe : d{3}s+d{3,8}.

Interprétons-le de gauche à droite :

d{3} signifie faire correspondre 3 nombres, tels que les

s peuvent correspondre à un espace (inclut également la tabulation ; et autres caractères d'espacement), donc s+ signifie qu'il y a au moins un espace, comme ' ', ' ', etc. ;

d{3,8} signifie 3 à 8 nombres, comme '1234567 ; '.

Ensemble, l'expression régulière ci-dessus peut faire correspondre des numéros de téléphone avec des indicatifs régionaux séparés par un nombre quelconque d'espaces.

Et si vous souhaitez faire correspondre un numéro tel que « 010-12345 » ? Puisque '-' est un caractère spécial, il doit être échappé avec '' dans les expressions régulières. Par conséquent, l'expression régulière ci-dessus est d{3}-d{3,8}.

Cependant, '010 - 12345' ne peut toujours pas correspondre à cause des espaces. Nous avons donc besoin de méthodes de correspondance plus complexes.

Recommandations associées : "Tutoriel vidéo Python"

Avancé

Pour une correspondance plus précise, vous pouvez utiliser [ ] représente une plage, par exemple :

[0-9a-zA-Z_] peut correspondre à un chiffre, une lettre ou un trait de soulignement

[0-9a-zA-Z_]+ peut correspondre au moins ; Une chaîne composée de chiffres, de lettres ou de traits de soulignement, tels que « a100 », « 0_Z », « Py3000 », etc.

[a-zA-Z_][0-9a-zA-Z_]* ; OK Correspond à une chaîne commençant par une lettre ou un trait de soulignement, suivi d'un nombre quelconque de chiffres, de lettres ou de traits de soulignement, qui est une variable légale en Python

[a-zA-Z_][0-9a-zA ; - Z_]{0, 19} limite plus précisément la longueur de la variable à 1-20 caractères (1 caractère devant + jusqu'à 19 caractères derrière).

A|B peut correspondre à A ou B, donc (P|p)ython peut correspondre à 'Python' ou 'python'.

^ signifie le début de la ligne, ^d signifie qu'elle doit commencer par un nombre.

$ indique la fin de la ligne, et d$ indique qu'elle doit se terminer par un chiffre.

Vous avez peut-être remarqué que py peut également correspondre à 'python', mais l'ajout de ^py$ correspondra à la ligne entière, et il ne peut correspondre qu'à 'py'.

re module

Avec les connaissances préparatoires, nous pouvons utiliser des expressions régulières en Python. Python fournit le module re, qui contient toutes les fonctions d'expression régulière. Puisque la chaîne de Python elle-même utilise également l'échappement, une attention particulière doit être portée à :

s = 'ABC\-001' # La chaîne de Python # La chaîne d'expression régulière correspondante devient : # 'ABC- 001'

Par conséquent, nous vous recommandons fortement d'utiliser le préfixe r de Python, afin que vous n'ayez pas à vous soucier de l'échappement :

s = r'ABC-001' # Chaîne Python# La chaîne d'expression régulière correspondante reste inchangée : # 'ABC-001'

Voyons d'abord comment déterminer si l'expression régulière correspond : la méthode

>>> import re
>>> re.match(r'^\d{3}\-\d{3,8}$', '010-12345')
<_sre.SRE_Match object; span=(0, 9), match=&#39;010-12345&#39;
>>>> re.match(r&#39;^\d{3}\-\d{3,8}$&#39;, &#39;010 12345&#39;)
>>>

match() détermine si elle correspond, si la correspondance est. réussi, renvoie un objet Match, sinon renvoie Aucun. La méthode de jugement courante est :

test = 'Chaîne entrée par l'utilisateur' if re.match(r'regular expression', test):

print('ok')else:
print('failed')

cut Fractionnement de chaîne

L'utilisation d'expressions régulières pour diviser des chaînes est plus flexible que l'utilisation de caractères fixes. Veuillez consulter le code de fractionnement normal :

>>> 'a b   c'.split(' ')
['a', 'b', '', '', 'c']

Eh bien, les espaces continus ne peuvent pas être reconnus, essayez d'utiliser des expressions régulières :

>>> re.split(r'\s+', 'a b   c')
['a', 'b', 'c']

Il peut être divisé normalement quel que soit le nombre d'espaces. Rejoignez, essayez :

>>> re.split(r'[\s\,]+', 'a,b, c  d')
['a', 'b', 'c', 'd']

Rejoignez-vous à nouveau ; essayez :

>>> re.split(r'[\s\,\;]+', 'a,b;; c  d')
['a', 'b', 'c', 'd']

Si l'utilisateur saisit un ensemble de balises, n'oubliez pas d'utiliser des expressions régulières pour convertir les entrées irrégulières en valeurs correctes la prochaine fois.

Groupe

除了简单地判断是否匹配之外，正则表达式还有提取子串的强大功能。用()表示的就是要提取的分组（Group）。比如：

^(\d{3})-(\d{3,8})$分别定义了两个组，可以直接从匹配的字符串中提取出区号和本地号码：

>>> m = re.match(r'^(\d{3})-(\d{3,8})$', '010-12345')
>>> m
<_sre.SRE_Match object; span=(0, 9), match=&#39;010-12345&#39;
>>>> m.group(0)&#39;010-12345&#39;
>>> m.group(1)&#39;010&#39;
>>> m.group(2)&#39;12345&#39;

如果正则表达式中定义了组，就可以在Match对象上用group()方法提取出子串来。

注意到group(0)永远是原始字符串，group(1)、group(2)……表示第1、2、……个子串。

提取子串非常有用。来看一个更凶残的例子：

>>> t = '19:05:30'
>>> m = re.match(r'^(0[0-9]|1[0-9]|2[0-3]|[0-9])\:(0[0-9]|1[0-9]|2[0-9]|3[0-9]|4[0-9]|5[0-9]|[0-9])\:(0[0-9]|1[0-9]|2[0-9]|3[0-9]|4[0-9]|5[0-9]|[0-9])$', t)>>> m.groups()
('19', '05', '30')

这个正则表达式可以直接识别合法的时间。但是有些时候，用正则表达式也无法做到完全验证，比如识别日期：

'^(0[1-9]|1[0-2]|[0-9])-(0[1-9]|1[0-9]|2[0-9]|3[0-1]|[0-9])$'

对于'2-30'，'4-31'这样的非法日期，用正则还是识别不了，或者说写出来非常困难，这时就需要程序配合识别了。

贪婪匹配

最后需要特别指出的是，正则匹配默认是贪婪匹配，也就是匹配尽可能多的字符。举例如下，匹配出数字后面的0：

>>> re.match(r'^(\d+)(0*)$', '102300').groups()
('102300', '')

由于\d+采用贪婪匹配，直接把后面的0全部匹配了，结果0*只能匹配空字符串了。

必须让\d+采用非贪婪匹配（也就是尽可能少匹配），才能把后面的0匹配出来，加个?就可以让\d+采用非贪婪匹配：

>>> re.match(r'^(\d+?)(0*)$', '102300').groups()
('1023', '00')

编译

当我们在Python中使用正则表达式时，re模块内部会干两件事情：

编译正则表达式，如果正则表达式的字符串本身不合法，会报错；

用编译后的正则表达式去匹配字符串。

如果一个正则表达式要重复使用几千次，出于效率的考虑，我们可以预编译该正则表达式，接下来重复使用时就不需要编译这个步骤了，直接匹配：

>>> import re
# 编译:
>>> re_telephone = re.compile(r'^(\d{3})-(\d{3,8})$')
# 使用：
>>> re_telephone.match('010-12345').groups()
('010', '12345')
>>> re_telephone.match('010-8086').groups()
('010', '8086')

编译后生成Regular Expression对象，由于该对象自己包含了正则表达式，所以调用对应的方法时不用给出正则字符串。

参数

修饰符

模式

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!