Python正则表达式

正则表达式是一个特殊的字符序列,他能帮助你方便的检查一个字符串是否与某种模式匹配。

re 模块使Python语言拥有全部的正则表达式功能。

²  re.match()函数:从字符串起始位置开始匹配,如果不是从起始位置匹配,返回None。

函数语法:

re.match(pattern, string, flags=0)

example

>>> import re
>>> s = 'If they do not match, you have two options.'
>>> print(re.match('If', s).group())
If
>>> print(re.match('you', s))
None

²  re.search()函数,扫描整个字符串并返回一个成功的匹配,如果字符串没有匹配,则返回None。

函数语法:

re.search(pattern, string, flag=0)

example

>>> import re
>>> print(re.search('\dcom', 'www.cccomround3com.0com').group())
3com
  •  re.match与re.search的区别

re.match()只匹配字符串的开始,如果字符串开始不匹配正则表达式,则匹配失败,函数返回None。

re.search()匹配整个字符串,知道找到一个匹配。

²  re.compile()函数:用于编译正则表达式,生成一个正则表达式(pattern)对象,供match()和search()两个函数使用。

函数语法

re.compile(pattern[, flags])

参数:

Pattern:一个字符串形式的正则表达式

Flags:可选,表示匹配模式,比如忽略大小写、多行模式等:

  1. re.I: 忽略大小写
  2. re.L: 表示特殊字符集\w, \W, \b, \B, \s, \S,依赖于当前环境。
  3. re.M: 多行模式,匹配多行,影响^和$(^增加匹配每行的开始,$增加匹配每行的结束)
  4. re.S: 即为.,使.匹配换行符在内的任意字符。
  5. re.U: 表示特殊字符集\w, \W, \s, \S, \b, \B, \d, \D,依赖于unicode字符属性数据库。
  6. re.X: 增加可读性,忽略空格和#后面的注释。

Example

>>> import re
>>> s = 'Making peace with what you do not have, that is what it is all about.'
>>> pattern = re.compile(r'\s*what\s')
>>> m = pattern.match(s)
>>> print(m)
None
>>> print(pattern.search(s))
<_sre.SRE_Match object; span=(17, 23), match=' what '>
>>> print(pattern.search(s).group())
 what

检索和替换

²  re.sub()函数,用于替换字符串中的匹配项,返回替换后的字符串。

函数语法:

re.sub(pattern, repl, string, count=0, flags=0)        

example

>>> import re
>>> s = 'So we can substitute that. They phone number is: 0571-56894388'
>>> print(re.sub('They', 'Our', s))
So we can substitute that. Our phone number is: 0571-56894388
>>> print(re.sub('\s+', '   ', s))
So   we   can   substitute   that.   They   phone   number   is:   0571-56894388
>>> print('电话号码:' + re.sub('\D', '', s))
电话号码:057156894388

repl也可以是函数:

>>> import re
>>> def double(matched):
...     value = int(matched.group('value'))
...     return str(value * 2)
...
>>> s = '12HJAS2840HAG'
>>> print(re.sub('(?P\d+)', double, s))

²  re.findall()函数:在字符串中找到正则表达式匹配的所有子串,并返回一个列表,如果没有找到匹配的,则返回一个空列表。

match()和search()是匹配一次,findall匹配所有。

函数语法:

re.findall(string, [, pos[, endpos]])

example

>>> import re
>>> pattern = re.compile(r'\w*at')
>>> s = 'Making peace with what you do not have, that is what it is all about.'
>>> print(pattern.findall(s))
['what', 'that', 'what']
>>> print(pattern.findall(s, 0, 30))
['what']

²  re.finditer()函数:和findall类似,在字符串中找到正则表达式匹配的所有子串,并把它们作为一个迭代器返回。

函数语法:

re.finditer(pattern, string, flags = 0)

example:

>>> import re
>>> rr = re.finditer('\d+', 'dfh1545dd=sfsgju44juy888uyk')
>>> for match in rr:
...     print(match)
...
<_sre.SRE_Match object; span=(3, 7), match='1545'>
<_sre.SRE_Match object; span=(16, 18), match='44'>
<_sre.SRE_Match object; span=(21, 24), match='888'>

²  re.split()函数:按照能够匹配的子串将字符串分割后返回列表。

函数语法:

re.split(pattern, string[, maxsplit=0, flags=0])

example:

>>> print(re.split(r'\s+', 'Every cloud has a silver lining.'))
['Every', 'cloud', 'has', 'a', 'silver', 'lining.']

正则表达式中的一些基本符号:

符号

解释

示例

说明

.

匹配任意字符

b.t

可以匹配but/bat/b#t/b1t等

\w

匹配字母/数字/下划线等

b\wt

可以匹配but/b1t/b_t等,但不能匹配b#t

\s

匹配空白字符(包括\r,\n,\t等)

Love\syou

可以匹配Love you

\d

匹配数字

\d\d

可以匹配01/99/32等

\b

匹配单词边界

\bThe\b

 

^

匹配字符串的开始

^The

可以匹配The开头的字符串

$

匹配字符串的结束

.exe$

可以匹配exe结尾的字符串

\W

匹配非字母/数字/下划线

b\Wt

可以匹配b#t/b@t等,但不能匹配but/b1t/b_t等

\S

匹配非空白字符

Love\Syou

可以匹配Love#you,但不能匹配Love you

\D

匹配非数字

\d\D

可以匹配3a/0F/9#等

\B

匹配非单词边界

\Bio\B

 

[]

匹配来自字符集的任一字符

[aeiou]

可以匹配任一元音字母字符

[^]

匹配不在字符集的任一字符

[aeiou]

可以匹配任一非元音字母字符

*

匹配0次或多次

\w*

 

+

匹配1次或多次

\w+

 

匹配0次或1次

\w?

 

{N}

匹配N次

\w{3}

匹配3次

{M,}

匹配至少M次

\w{3,}

匹配至少3次

{M,N}

匹配至少M次至多N次

\w{3,6}

匹配至少3次至多6次

|

分支

foo|bar

可以匹配foo或者bar

(?#)

注释

 

 

(exp)

匹配exp并捕获到自动命名的组中

 

 

(?exp)

匹配exp并捕获到命名为name的组中

 

 

(?:exp)

匹配exp但不捕获匹配的文本

 

 

(?=exp)

匹配exp前面的位置

\b\w+

(?=ing)

可以匹配I’m dancing中的danc

(?<=exp)

匹配exp后面的位置

(?<=\bdanc)

\w+\b

可以匹配到I love dancing and reading中的第一个ing

(?!exp)

匹配后面不是exp的位置

 

 

(?

匹配前面不是exp的位置

 

 

*?

匹配任意次,但尽可能少重复

a.*b

a.*?b

将正则表达式应用于aabab,前者会匹配整个字符串aabab,后者会匹配aab和ab两个字符串

+?

匹配1次或多次,但尽可能少重复

 

 

{M,N}?

匹配M到N次,但尽可能少重复

 

 

{M,}?

匹配M次以上,但尽可能少重复

 

 

转载于:https://www.cnblogs.com/Grace-gao/p/11398923.html

你可能感兴趣的:(Python正则表达式)