Python-正则表达式

标签：cas   解析   判断   打印   sof   data-   扩展   国际化   逻辑或   

简介

正则表达式（简称为 regex）是一些由字符和特殊符号组成的字符串，

它们描述了模式的重复或者表述多个字符

于是正则表达式能按照某种模式匹配一系列有相似特征的字符串

便捷的操作文本或者数据 。

简单的正则匹配

特殊符号和字符

常见的特殊符号和字符，即所谓的元字符，正是它给予正则表达式强大的功能和灵活性。

本节将介绍最常见的特殊符号和字符，即所谓的元字符，正是它给予正则表达式强大的功能和灵活性。

常见正则表达式符号和特殊字符

使用择一匹配符号匹配多个正则表达式模式

表示择一匹配的管道符号（ |），也就是键盘上的竖线，表示一个“从多个模式中选择其一”的操作。

它用于分割不同的正则表达式。

匹配任意单个字符

点号或者句点（ .） 符号匹配除了换行符\n 以外的任何字符

（Python 正则表达式有一个编译标记[S 或者 DOTALL]，该标记能够推翻这个限制，使点号能够匹配换行符）。

无论字母、数字、 空格（并不包括“\n”换行符）、可打印字符、 不可打印字符，

还是一个符号，使用点号都能够匹配它们。

要显式匹配一个句点符号本身，必须使用反斜线转义句点符号的功能，例如“.”

从字符串起始或者结尾或者单词边界匹配

还有些符号和相关的特殊字符用于在字符串的起始和结尾部分指定用于搜索的模式。如

果要匹配字符串的开始位置，就必须使用脱字符（^）或者特殊字符\A

后者主要用于那些没有脱字符的键盘（例如，某些国际键盘）。

同样，美元符号（$）或者\Z将用于匹配字符串的末尾位置。

再次说明，如果想要逐字匹配这些字符中的任何一个（或者全部），就必须使用反斜线进行转义。

例如，如果你想要匹配任何以美元符号结尾的字符串，一个可行的正则表达式方案，就是使用模式.*$$

特殊字符\b 和\B 可以用来匹配字符边界。

而两者的区别在于\b 将用于匹配一个单词的边界，这意味着如果一个模式必须位于单词的起始部分，

就不管该单词前面（单词位于字符串中间）是否有任何字符（单词位于行首）。

同样， \B 将匹配出现在一个单词中间的模式（即，不是单词边界）。

创建字符集

尽管句点可以用于匹配任意符号，但某些时候，可能想要匹配某些特定字符。

正因如此，发明了方括号。该正则表达式能够匹配一对方括号中包含的任何字符。

关于

crdp这个正则表达式有一点需要说明：如果仅允许“r2d2”或者“c3po”作为有效字符串，

就需要更严格限定的正则表达式。

因为方括号仅仅表示逻辑或的功能，所以使用方括号并不能实现这一限定要求。

唯一的方案就是使用择一匹配，例如，r2d2|c3po。

限定范围和否定

除了单字符以外，字符集还支持匹配指定的字符范围。方括号中两个符号中间用连字符 (-)连接，用于指定一个字符的范围；

例如， A-Z、 a-z 或者 0-9 分别用于表示大写字母、 小写字母和数值数字。

使用闭包操作符实现存在性和频数匹配

本节介绍最常用的正则表达式符号， 即特殊符号*、 +和？，

所有这些都可以用于匹配一个、 多个或者没有出现的字符串模式。

星号或者星号操作符（*）将匹配其左边的正则表达式出现零次或者多次的情况

（在计算机编程语言和编译原理中，该操作称为 Kleene 闭包）

加号（+）操作符将匹配一次或者多次出现的正则表达式（也叫做正闭包操作符）

问号（？）操作符将匹配零次或者一次出现的正则表达式。

还有大括号操作符（ {}），里面或者是单个值或者是一对由逗号分隔的值。

这将最终精确地匹配前面的正则表达式

N 次（如果是{N}）或者一定范围的次数；例如， {M， N}

将匹配 M～N 次出现。

这些符号能够由反斜线符号转义； \ *匹配星号，等等。 注意，在之前的表格中曾经多次使用问号（重载）， 这意味着要么匹配 0 次，要么匹配 1次，

或者其他含义：

如果问号紧跟在任何使用闭合操作符的匹配后面， 它将直接要求正则表达式引擎匹配尽可能少的次数。

“尽可能少的次数” 是什么意思？

当模式匹配使用分组操作符时，正则表达式引擎将试图“吸收”匹配该模式的尽可能多的字符。

这通常被叫做贪婪匹配。

问号要求正则表达式引擎去“偷懒”，如果可能，就在当前的正则表达式中尽可能少地匹配字符，

留下尽可能多的字符给后面的模式（如果存在）。

非贪婪匹配是很有必要的。

表示字符集的特殊字符

我们还提到有一些特殊字符能够表示字符集。

与使用“0-9”这个范围表示十进制数相比，可以简单地使用 \d 表示匹配任何十进制数字。

另一个特殊字符（\w） 能够用于表示全部字母数字的字符集，相当于[A-Za-z0-9_]的缩写形式，

\s 可以用来表示空格字符。

这些特殊字符的大写版本表示不匹配；

例如， \D 表示任何非十进制数（与[\^0-9]相同）， 等等。

使用这些缩写，可以表示如下一些更复杂的示例。

使用圆括号指定分组

现在，我们已经可以实现匹配某个字符串以及丢弃不匹配的字符串，

但有些时候，我们可能会对之前匹配成功的数据更感兴趣。

我们不仅想要知道整个字符串是否匹配我们的标准， 而且想要知道能否提取任何已经成功匹配的特定字符串或者子字符串。

答案是可以，要实现这个目标，只要用一对圆括号包裹任何正则表达式。

扩展表示法

我们还没介绍过的正则表达式的最后一个方面是扩展表示法， 它们是以问号开始（?…）。

我们不会为此花费太多时间，因为它们通常用于在判断匹配之前提供标记，

实现一个前视（或者后视）匹配，或者条件检查。

尽管圆括号使用这些符号， 但是只有（?P<name>） 表述一个分组匹配。

所有其他的都没有创建一个分组。

然而，你仍然需要知道它们是什么，因为它们可能最适合用于你所需要完成的任务。

正则表达式和python语言

python使用re模块支持正则表达式

主要函数：match()、search()、compile()

使用 compile()函数编译正则表达式

注意，尽管推荐预编译，但它并不是必需的。

如果需要编译，就使用编译过的方法；如果不需要编译，就使用函数。

(？ F) 标记，其中 F 是一个或者多个 i（用于 re.I/IGNORECASE）、

m（用于 re.M/MULTILINE）、s（用于 re.S/DOTALL） 等。

如果想要同时使用多个，就把它们放在一起而不是使用按位或操作

例如，（?im） 可以用于同时表示 re.IGNORECASE 和 re.MULTILINE。

匹配对象以及 group()和 groups()方法

当处理正则表达式时，除了正则表达式对象之外，还有另一个对象类型：匹配对象。

这些是成功调用 match()或者 search()返回的对象。

匹配对象有两个主要的方法： group()和groups()。

group()要么返回整个匹配对象，要么根据要求返回特定子组。

groups()则仅返回一个包含唯一或者全部子组的元组。

如果没有子组的要求，那么当group()仍然返回整个匹配时， groups()返回一个空元组。

使用 match()方法匹配字符串

match()是将要介绍的第一个 re 模块函数和正则表达式对象（ regex object）方法。

match()函数试图从字符串的起始部分对模式进行匹配。

如果匹配成功，就返回一个匹配对象；

如果匹配失败，就返回 None，匹配对象的 group()方法能够用于显示那个成功的匹配。

m = re.match(‘foo‘,‘foo‘)   #模式匹配字符串
if m is not None:   #如果匹配成功，就输出匹配内容
    a=m.group()
    print(a)

使用 search()在一个字符串中查找模式（搜索与匹配的对比）

search() 搜索的模式出现在一个字符串中间部分的概率 。

search()会用它的字符串参数，在任意位置对给定正则表达式模式搜索第一次出现的匹配情况。

如果搜索到成功的匹配，就会返回一个匹配对象； 否则， 返回 None。

m = re.search(‘foo‘,‘seafood‘)  #使用search代替match，若是match会搜索失败
if m is not None:
    a=m.group()
    print(a)

匹配多个字符串

bt = ‘bat|bet|bit‘      # 正则表达式模式: bat、 bet、 bit 
?
m = re.match(bt, ‘bat‘)     # ‘bat‘ 是一个匹配 
?
if m is not None:
    a=m.group() 
    print(a)

匹配任何单个字符

anyend = ‘.end‘
m = re.match(anyend, ‘bend‘)    # 点号匹配 ‘b‘
if m is not None:
    a=m.group()
    print(a)

创建字符集（[ ]）

m = re.match(‘[cr][23][dp][o2]‘, ‘c3po‘)# 匹配 ‘c3po‘
if m is not None:
    a=m.group()
    print(a)

匹配子组

m = re.match(‘(\w\w\w)-(\d\d\d)‘, ‘abc-123‘)
?
m.group() # 完整匹配
?
‘abc-123‘
?
m.group(1) # 子组 1
?
‘abc‘
?
m.group(2) # 子组 2
?
‘123‘
?
m.groups() # 全部子组
?
(‘abc‘, ‘123‘)

匹配字符串的起始和结尾以及单词边界

m = re.search(‘^The‘, ‘The end.‘) # 匹配
?
if m is not None: m.group()
?
...
?
‘The‘
?
m = re.search(‘^The‘, ‘end. The‘) # 不作为起始
?
if m is not None: m.group()
    
...
?
m = re.search(r‘\bthe‘, ‘bite the dog‘) # 在边界
?
if m is not None: m.group()
    
...
?
‘the‘
?
m = re.search(r‘\bthe‘, ‘bitethe dog‘) # 有边界
?
if m is not None: m.group()
...
m = re.search(r‘\Bthe‘, ‘bitethe dog‘) # 没有边界
?
if m is not None: m.group()
    
...
?
‘the‘

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

findall()查询字符串中某个正则表达式模式全部的非重复出现情况。

这与 search()在执行字符串搜索时类似，但与 match()和 search()的不同之处在于， findall()总是返回一个列表

如果 findall()没有找到匹配的部分，就返回一个空列表，但如果匹配成功

列表将包含所有成功的匹配部分（从左向右按出现顺序排列）

re.findall(‘car‘, ‘car‘)
?
[‘car‘]
?
re.findall(‘car‘, ‘scary‘)
?
[‘car‘]
?
re.findall(‘car‘, ‘carry the barcardi to the car‘)
?
[‘car‘, ‘car‘, ‘car‘]

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

有两个函数/方法用于实现搜索和替换功能： sub()和 subn()。

两者几乎一样，都是将某字符串中所有匹配正则表达式的部分进行某种形式的替换。

用来替换的部分通常是一个字符串，但它也可能是一个函数，该函数返回一个用来替换的字符串。

subn()和 sub()一样，但 subn()还返回一个表示替换的总数，

替换后的字符串和表示替换总数的数字一起作为一个拥有两个元素的元组返回。

re.sub(‘X‘, ‘Mr. Smith‘, ‘attn: X\n\nDear X,\n‘)
?
‘attn: Mr. Smith\012\012Dear Mr. Smith,\012‘
?
re.subn(‘X‘, ‘Mr. Smith‘, ‘attn: X\n\nDear X,\n‘)
?
(‘attn: Mr. Smith\012\012Dear Mr. Smith,\012‘, 2)
?
print re.sub(‘X‘, ‘Mr. Smith‘, ‘attn: X\n\nDear X,\n‘)
?
attn: Mr. Smith
    
Dear Mr. Smith,
?
re.sub(‘[ae]‘, ‘X‘, ‘abcdef‘)
?
‘XbcdXf‘
?
re.subn(‘[ae]‘, ‘X‘, ‘abcdef‘)
?
(‘XbcdXf‘, 2)

在限定模式上使用 split()分隔字符串

re 模块和正则表达式的对象方法 split()对于相对应字符串的工作方式是类似的，

但是与分割一个固定字符串相比，它们基于正则表达式的模式分隔字符串，

为字符串分隔功能添加一些额外的威力。

如果你不想为每次模式的出现都分割字符串，就可以通过为 max 参数设定一个值（非零）来指定最大分割数。

如果给定分隔符不是使用特殊符号来匹配多重模式的正则表达式，

那么 re.split()与str.split()的工作方式相同，如下所示（基于单引号分割）。

re.split(‘:‘, ‘str1:str2:str3‘)
?
[‘str1‘, ‘str2‘, ‘str3‘] 

有一个更复杂的示例，例如，一个用于 Web 站点（类似于Google 或者 Yahoo! Maps）的简单解析器，

该如何实现？用户需要输入城市和州名，或者城市名加上 ZIP 编码， 还是三者同时输入？

这就需要比仅仅是普通字符串分割更强大的处理方式，具体如下

import re
?
DATA = (‘Mountain View, CA 94040‘,‘Sunnyvale, CA‘, ‘Los Altos, 94023‘, ‘Cupertino 95014‘,‘Palo Alto CA‘,)
?
for datum in DATA:
    print re.split(‘, |(?= (?:\d{5}|[A-Z]{2})) ‘, datum)
?
[‘Mountain View‘, ‘CA‘, ‘94040‘]
?
[‘Sunnyvale‘, ‘CA‘]
?
[‘Los Altos‘, ‘94023‘]
?
[‘Cupertino‘, ‘95014‘]
?
[‘Palo Alto‘, ‘CA‘]

一些正则表达式示例

以 POSIX（UNIX 风格操作系统，如 Linux、 Mac OS X 等）的 who 命令的输出为例

该命令将列出所有登录当前系统中的用户信息。

创建一个名为 rewho.py 的程序，该程序读取 who 命令的输出，

然后假定将得到的输出信息存入一个名为 whoadat.txt 的文件之中

py2.x-py3.x通用

#!/usr/bin/env python
?
import os
from distutils.log import warn as printf
import re
?
with os.popen(‘who‘,‘r‘) as f:
    for eachLine in f:
        printf(re.split(r‘\s\s+|\t‘,eachLine.strip()))

匹配字符串

以子组的方式来访问匹配字符串。

patt = ‘^(Mon|Tue|Wed|Thu|Fri|Sat|Sun)‘
?
m = re.match(patt, data)
?
m.group() # entire match
?
‘Thu‘
?
m.group(1) # subgroup 1
?
‘Thu‘
?
m.groups() # all subgroups
?
(‘Thu‘,)

以上两个正则表达式都是非常严格的，尤其是要求一个字符串集。

这可能在一个国际化的环境中并不能良好地工作，因为所在的环境中会使用当地的日期和缩写。

一个宽松的正则表达式将为： ^\w{3}。

该正则表达式仅仅需要一个以三个连续字母数字字符开头的字符串。

再一次，将正则表达式转换为正常的自然语言：

脱字符^表示“作为起始”， \w 表示任意单个字母数字字符， {3}表示将会有 3 个连续的正则表达式副本，

这里使用{3}来修饰正则表达式。

再一次，如果想要分组，就必须使用圆括号，例如^(\w{3})。

patt = ‘^(\w{3})‘
?
m = re.match(patt, data)
?
if m is not None: m.group()
?
‘Thu‘
?
m.group(1)
?
‘Thu‘

注意， 正则表达式^(\w){3}是错误的。

当{3}在圆括号中时，先匹配三个连续的字母数字字符，然后表示为一个分组。

但是如果将{3}移到外部， 它就等效于三个连续的单个字母数字字符。

patt = ‘^(\w){3}‘
?
m = re.match(patt, data)
?
if m is not None: m.group()
?
‘Thu‘
?
m.group(1)
?
‘u‘

当我们访问子组 1 时，出现字母“u”的原因是子组 1 持续被下一个字符替换。

换句话说，m.group(1)以字母“T”作为开始，然后变为“h”，最终被替换为“u”。

这些是单个字母数字字符的三个独立（并且重叠）分组，与一个包含三个连续字母数字字符的单独分组相反。

Python-正则表达式

标签：cas   解析   判断   打印   sof   data-   扩展   国际化   逻辑或   

原文地址：https://www.cnblogs.com/wintrysec/p/10616742.html