正则表达式的作用在这里不多赘述了,反正处理文本任务贼六就对了。Python中的正则表达式是内置在re模块中的,我们就对这个模块进行详细地讲解。这是一篇媲美帮助文档的文章!对就这么自信,不服你顺着网线来打我呀!8-)
再次更新于2018-9-21
目录
RE模块
特殊字符
元符号:. ^ $ * + ? { } [ ] \ | ( )
元符号 | 用法和例子 |
---|---|
. | 默认模式下,匹配换行符以外的任何字符。若 re.DOTALL标志被指定,则它匹配换行符在内的任何字符。 例:>>> re.search('.',"I love China") |
^ | 从字符串的开始匹配, 在 re.MULTILINE模式下每个换行符后面立即开始匹配。 例:>>> re.search(r'^ab',"abcdefg") |
$ | 与上面的相对,匹配字符串的结尾或只是之前换行符结尾的字符串,并在 例:>>> re.search(r'fg$',"abcdefg") |
* | 匹配前面的子表达式零次或多次(贪婪模式1),等价于{0}。 例:>>> re.search(r'a*','aaaaaab') |
+ | 匹配前面的子表达式一次或多次(贪婪模式),等价于{1}。 例:>>> re.search(r'a+','aaaaaab') |
? | 匹配前面的子表达式零次或一次,等价于{0,1}。
|
*? ,+? ,?? |
默认情况下,*,+,?是贪婪模式,后面再加个?可以启用非贪婪模式。 例:>>> re.search(r'a*?','aaaaaab') |
{m} | 精确的指定RE应该被匹配m次,少于m次将导致RE不会被匹配上。 例:>>> print(re.search(r'a{5}','aaaab')) |
{m,n} | m和n都为非负数,且m<n,其表示前面的RE匹配[m,n],默认也为贪婪模式,后面加上?后可启用非贪婪模式。省略m指定零为下限,省略n指定无穷大为上限。2 例:>>> re.search(r'a{1,4}','aaaaaaab') |
\ | 特殊符号消除术,消除特殊字符含义(允许匹配像 例:>>> re.search(r'\.','www.aoxiangzhonghua.com') |
[] | 用来表示一个字符集合。在这个集合中: 例如:>>> re.search(r'[\[]',"[]")
|
| | 类似于C语言中的或操作,A|B表示匹配正则表达式A或者B。 例:>>> re.search(r'ab|cd','acdf') |
(...) | 子组,将匹配圆括号内的正则表达式,并指明子组的开始和结束。子组的内容可以在后面通过\number再次引用(稍后提及)。 例:>>> re.search(r'(efg)','abcdefghj') |
拓展语法部分 | ?开头的正则表达式为拓展语法,格式如(?...) |
(?aiLmsux) | 例:>>> re.search(r'(?i)CHINA','我爱China')
|
(?:...) | 非捕获组,即该子组匹配的字符串无法从后面获得。 例:>>> re.search(r'(?:China)\1','ChinaChina') |
(?P<name>...) | 为匹配的正则表达式取别名(即除了原有的编号外再指定一个额外的别名),<>为取的别名,每个组名称在正则表达式中只能被定义一次。 |
(?P=name) | 引用别名为name的子组。 例:>>> print(re.search(r'(?P<love>China)(?P=love)','aaaChinaChinabbb')) |
(?#...) |
注释,将忽略括号内的内容。 例:>>> re.search(r'(?#啦啦啦)China','I love China') |
(?=...) | 前向肯定断言,如果 例:>>> re.search(r'love (?=China)','I love China') |
(?!...) | 与上一个作用相反,如果...不匹配时后面的内容时才算匹配,也举个例子。 例:>>> re.search(r'love (?!America)','I love China') |
(?<=...) | 后向肯定断言,只有当...匹配之前的内容时才算匹配,举个例子就懂。 例:>>> re.search(r'(?<=I) love','I love China') |
(?<!...) | 与上一个作用相反,如果...不匹配之前的内容才算匹配,举个例子。 例:>>> re.search(r'(?<!Y) love','I love China') |
(?(id/name) yes-pattern|no-pattern) |
如果具有给定 id 或 name 的组存在,将尝试匹配 例:>>> re.search(r'(I )(?(1)love|hate)','I love China') #说明,这里开始‘I ‘匹配,所以再启用yes-pattern进行匹配,这里即'love' ,这里的1是id,指代第一组子组,当然前面如果设置name,这里也可以用name来指代。 >>> re.search(r'(Y )?(?(1)hate|love)','I love China') #说明,这里开始’Y ‘不匹配,所以再启用no-pattern进行匹配,即'love'。这里第一个问号是为了当第一个括号中的内容不匹配时,跳过开头进行匹配,因为前面不匹配的内容会消耗字符串中等量的字符。
|
反斜杠加普通字符 | 特殊含义 |
\number | 匹配相对应子组编号的内容,组号从1开始。该特殊序列只能用于匹配前99个组中的一个。如果number的第一个数字为0或number为3个八进制数字,则不会将其解释为组匹配,而是八进制值,这时表示对应ASCII值的字符。 例:>>> re.search(r'(I (love))\2','I lovelove China') |
|
仅仅匹配字符串开头。 例:>>> re.search(r'\AI','I love China') |
\b | 匹配一个单词的边界。这里的单词的定义是由Unicode字母数字或下划线组成的序列,因此单词的边界由空格、非字母数字或非下划线Unicode字符表示。我们可以这么简单理解,一个\b即替代一个空格、非字母数字或非下划线Unicode字符表示的边界。默认情况下,使用Unicode字母和数字,但可以通过使用re.ASCII标志来更改。在字符范围内, 例:>>> re.search(r'\blove\b','I love China') |
\B | 与\b作用相反,匹配非单词边界。 例:>>> re.search(r'\Blove\B','IloveChina') |
\d | 对于Unicode模式: 匹配任何Unicode十进制数字。这包括 对于ASCII模式: 匹配任何十进制数字;这相当于 例:>>> re.search(r'\d\d','I 52 China') |
\D | 匹配任何不是Unicode十进制数字的字符。这与 例:>>> re.search(r'\D','5 love China') |
\s |
对于Unicode模式: 匹配Unicode空白字符(包括 对于ASCII模式: 匹配ASCII字符集中空白的字符;相当于 例:>>> re.search(r'\s','I love China') |
\S | 作用与\s相反,匹配不是Unicode空白字符,如果设置re.ASCII标志,则相当于 例:>>> re.search(r'\S','I love China') |
\w | 对于Unicode模式: 匹配Unicode字符,这包括大多数可以是任何语言的单词的一部分的字符,以及数字和下划线,注意,不能匹配逗号,句号,问号等符号。 对于ASCII模式: 匹配ASCII字符集,这相当于 例:>>> re.search(r'\w','I love China') |
\W | 与\w作用相反,匹配非Unicode字符,如果设置了re.ASCII标志,则不匹配ASCII字符。 例:>>> re.search(r'\W','I love China') |
\Z | 只匹配字符串结尾。 例:>>> re.search(r3'China\Z','I love China') |
转义字符 | 正则表达式还支持大部分 Python 字符串的转义符号:\a,\b,\f,\n,\r,\t,\u,\U,\v,\x,\\ |
补充说明
1.贪婪模式指尽可能多的匹配字符。
例:>>> re.search(r'a*','aaaaaab')
<_sre.SRE_Match object; span=(0, 6), match='aaaaaa'> #这个例子中,正则表达式尽可能多地匹配a字符直至不满足条件。
2.这里的无穷大不是真的无穷大,由于受到 C 语言的 int 类型大小的内部限制,其上界为20多亿,但这再实际应用中完全足够大。
3.有细心的童鞋可能注意到我们这里的RE表达式都采用原始字符串形式,因为这样可能避免\过分放飞自我,举个例子:
如果不适用原始字符串,我要匹配两个\要写成以下格式:re.search('\\\\','\\'),因为\\才会转义成\,而使用原始字符串只需写成re.search(r'\\','\\'),是不是简洁不少。
模块内容
模块定义了几个函数、 常量和一个异常。某些函数是编译正则表达式全特性方法的简化版本。大多数复杂应用程序总是使用已编译的形式。
模块函数 | 用法讲解及举例 |
re. compile (pattern, flags=0) |
将正则表达式模式编译成正则表达式对象4,patten是正则表达式,flag是标志位,默认不设置。表达式在单个程序中多次使用时, 使用 例:>>> regex = re.compile(r'love') |
re. search (pattern, string, flags=0) |
搜索函数,寻找正则表达式 pattern 产生匹配的第一个位置,并返回相应的 match object。 前面举得很多例子都用到这个函数这里不赘述。 |
re. match (pattern, string, flags=0) |
这个函数只会试图去匹配string字符串的开始位置,如果开始位置不符合则匹配失败。 例:>>> re.match(r'l','I love China') #返回None,即匹配失败。 |
re. fullmatch (pattern, string, flags=0) |
如果整个字符串匹配正则表达式pattern,则返回相应的match object。若该 string 不匹配该 pattern ,返回 例:>>> re.fullmatch(r'I love China','I love China') |
re. split (pattern, string, maxsplit=0, flags=0) |
根据pattern的匹配拆分字符串。如果在pattern中使用捕获括号,则模式中所有组的文本也会作为结果的一部分返回。如果maxsplit(最多分割次数)不为零,则至多出现maxsplit分裂,并且字符串的其余部分作为列表的最后一个元素返回。 例:>>> re.split(r' ','I love China') >>> re.split(r'( )','I love China') |
re. findall (pattern, string, flags=0) |
返回字符串中pattern的所有非重叠匹配项作为字符串列表。对string是从左到右扫描的,所以匹配的内容是按照该顺序来的,如果模式中存在一个或多个组,会返回子组列表;如果模式有多个组,会返回一个元组列表。5 例:>>> re.findall(r'love','love I love China love') |
re. finditer (pattern, string, flags=0) |
返回与patten匹配的match object组成的迭代器。对string是从左到右扫描的,所以匹配的内容是按照该顺序来的。 例:>>> for each in re.finditer(r'love','love I love China love'): |
re. sub (pattern, repl, string, count=0, flags=0) |
将于正则表达式匹配的部分替换成设定的repl,repl 可以是一个字符串或一个函数6;如果是一个字符串, 则会处理每个反斜杠转义。 例:>>> re.sub(r'hate','love','I hate China') |
|
执行与sub()相同的操作,但返回一个元组 例:>>> re.subn(r'hate','love','I hate China') |
re. escape (string) |
转义模式中除ASCII字母、数字和'_' 之外的所有字符。如果你想匹配任何可能具有正则表达式元字符的文本字符串,这非常有用。(笔者也不知道啥意思(@_@;)) |
|
清除正则表达式缓存。 |
模块常量 | 用法介绍 |
|
让 例:>>> re.search(r'\w','我爱China',re.A) |
|
显示关于编译表达式的调试信息。(不怎用) |
|
执行不区分大小写的匹配,如 例:>>> re.search(r'CHINA',' I love China',re.I) |
|
自版本3.5起弃用。 |
|
指定时,模式字符 例:>>> re.search(r'^T','I love China\nT love Chian\nU love China',re.M) |
|
将使'.' 特殊字符完全匹配任何字符,包括换行符,没有这个标志,'.' 会匹配除换行符之外的任何。例:>>> re.search(r'.','\n',re.S) <_sre.SRE_Match object; span=(0, 1), match='\n'> |
|
该标志允许您编写正则表达式,允许您使用空格并添加注释,使正则表达式看起来更好,并且更易读。 例:charref = re.compile(r""" &[#] # 开始数字引用 ( 0[0-7]+ # 八进制格式 | [0-9]+ # 十进制格式 | x[0-9a-fA-F]+ # 十六进制格式 ) ; # 结尾分号 """, re.VERBOSE) |
补充说明
4.其实再使用模块函数譬如re.search()时,如果匹配成功其就会返回match object即匹配对象。
5.子组的这个特性很好用,
例:>>> re.findall(r'(..(love)(..))','I love China U love China T love China')
[('I love C', 'love', ' C'), ('U love C', 'love', ' C'), ('T love C', 'love', ' C')]
可以很方便的返回子组匹配成功的子字符串,当然我们也可以使其只返回整体的形式,不单独返回子组中的内容,(?:...),
例:>>> re.findall(r'(?:..(?:love)(?:..))','I love China U love China T love China')
['I love C', 'U love C', 'T love C']
这里我们也要对子组的编号做说明,左括号出现的顺序就是编号顺序,就拿上面的例子来说明,正则表达式中最开始的(为(..(love)(..)),所以该子组编号为1,第二个左括号(为 (love),所以该子组的编号为2,第三个左括号(为(..),所以其编号为3。
6.对sub函数repl参数进行说明,这个参数可以为函数,这就给我们很大的自由,相当于我们可以自由来定义规则。
例:>>> def my_replace(matchobj):
if matchobj.group(0) == 'hate': #关于group函数的用法稍后给出
return 'love'
>>> re.sub(r'hate',my_replace,'I hate China')
'I love China'
正则表达式对象
正则表达式对象只不过是把之前的正则表达式编译成一个对象,这样的好处是后面使用时可以直接拿来用,不用重复地写正则表达式。其内置方法和re模块内容中的函数差不多,再此我们不赘述,只给出其内置函数的名称和用法。
正则表达式对象内置方法 | 用法 |
regex7. search (string[, pos[, endpos]]) |
搜索函数,寻找正则表达式 pattern 产生匹配的第一个位置,并返回相应的 match object。 前面举得很多例子都用到这个函数这里不赘述。类同 |
regex. match (string[, pos[, endpos]]) |
这个函数只会试图去匹配string字符串的开始位置,如果开始位置不符合则匹配失败。类同re. match (pattern, string, flags=0)。 |
regex. fullmatch (string[, pos[, endpos]]) |
如果整个字符串匹配正则表达式pattern,则返回相应的match object。若该 string 不匹配该 pattern ,返回 None。类同re. fullmatch (pattern, string, flags=0)。 |
regex. split (string, maxsplit=0) |
根据pattern的匹配拆分字符串。如果在pattern中使用捕获括号,则模式中所有组的文本也会作为结果的一部分返回。如果maxsplit(最多分割次数)不为零,则至多出现maxsplit分裂,并且字符串的其余部分作为列表的最后一个元素返回。类同re. split (pattern, string, maxsplit=0, flags=0)。 |
regex. findall (string[, pos[, endpos]]) |
返回字符串中pattern的所有非重叠匹配项作为字符串列表。对string是从左到右扫描的,所以匹配的内容是按照该顺序来的,如果模式中存在一个或多个组,会返回子组列表;如果模式有多个组,会返回一个元组列表。类同re. findall (pattern, string, flags=0)。 |
regex. finditer (string[, pos[, endpos]]) |
返回与patten匹配的match object组成的迭代器。对string是从左到右扫描的,所以匹配的内容是按照该顺序来的。类同re. finditer (pattern, string, flags=0)。 |
regex. sub (repl, string, count=0) |
将于正则表达式匹配的部分替换成设定的repl,repl 可以是一个字符串或一个函数6;如果是一个字符串, 则会处理每个反斜杠转义。类同re. sub (pattern, repl, string, count=0, flags=0)。 |
regex. subn (repl, string, count=0) |
执行与sub()相同的操作,但返回一个元组(替换后的字符串,替换次数) 。类同re. subn (pattern, repl, string, count=0, flags=0)。 |
正则表达式对象内置方法 | 介绍和举例 |
regex. flags |
记录正则表达式匹配标志。 例:>>> regex = re.compile(r'CHINA',re.I) |
|
模式中的捕获组数量。 例:>>> regex = re.compile(r'(CHINA)',re.I) |
regex. groupindex |
将由 例:>>> regex = re.compile(r'(?P<name>CHINA)',re.I) |
regex. pattern |
返回编译RE对象的模式字符串。 例:>>> regex = re.compile(r'(?P<name>CHINA)',re.I) >>> regex.pattern |
7.regex为编译好的正则表达式对象。
匹配对象(Match Object)
当正则表达式匹配成功时将返回Match Object,该对象也有很多内置属性和方法。
内置方法 | 用法和举例 |
|
如sub()方法所做的那样,返回通过对模板字符串template执行反斜杠替换获得的字符串。像 例:>>> matchobj = re.search(r'(China)\1','ChinaChina') >>> matchobj.expand(r'\1') #类似引用前面匹配对象中的子组 |
match. group ([group1, ...]) |
返回匹配的一个或多个子组。如果有一个参数,结果是一个单一的字符串;如果有多个参数,则结果是各个参数对应的子组。如果没有参数, group1默认为零 (返回整个match的匹配结果)。如果groupN参数为零,则相应的返回值是整个匹配的字符串;如果它在包含范围[1..99]中,则它是匹配相应括号组的字符串。如果组编号为负数或大于模式中定义的组数,则引发IndexError异常。如果一个组包含在不匹配的模式的一部分中,则相应的结果是 例:>>> re.search(r'(\w+) (\w+) (\w+)','I love China') |
match. groups (default=None) |
返回一个包含匹配所有子组的元组,从1开始,default的作用是但不是全部子组匹配时则不匹配的子组返回default。 例:>>> re.search(r'(\d+)\.?(\d+)?','3').groups('第二个子组没匹配') #这里点号后面的内容可省略,当省略时第二个子组就未匹配,此时返回defult值。 |
match. groupdict (default=None) |
返回一个有别名的组的匹配子组的字典(没有别名的子组不包含在内)。键为子组名,值为子串。默认参数用于未参与匹配的组,它默认为 例:>>> re.search(r'(?P<name1>I )(?P<name2>love )(?P<name3>China)','I love China').groupdict() |
match. start ([group]) |
匹配开始的位置。 例:>>> re.search(r'love','I love China').start() |
match. end ([group]) |
匹配结束的位置。 例:>>> re.search(r'love','I love China').end() |
match. span ([group]) |
匹配范围。 例:>>> re.search(r'love','I love China').span() |
内置属性 | 介绍和例子 |
match. pos |
这是RE引擎开始寻找匹配的字符串的索引。 例:>>> re.search(r'love','I love China').pos |
match. endpos |
这是RE引擎匹配的字符串结束的索引。 例:>>> re.search(r'love','I love China').endpos |
match. lastindex |
最后一个匹配捕获组的整数索引,或者 例:>>> re.search(r'(\w+) (\w+) (\w+)','I love China').lastindex |
match. lastgroup |
最后匹配的捕获组的名称,如果组没有名称,或者根本没有匹配组,则 例:>>> re.search(r'(?P<name1>I )(?P<name2>love )(?P<name3>China)','I love China').lastgroup |
match. re |
编译的正则表达式。 例:>>> re.search(r'(\w+) (\w+) (\w+)','I love China').re |
match. string |
被 例:>>> re.search(r'(\w+) (\w+)','I love China').string |
至此,关于python正则表达式几乎所有的内容及用法都讲完了,祝君进步!
参考资料: