python re正则匹配_Python_re正则表达式

正则表达式： 匹配字符串

re.compile():用于编译正则表达式，生成一个正则表达式对象，供 match() 和 search() 两个函数使用，一般建议使用这种编译方式

1 importre2 str = 'abc1def2ghi3jkl4mn'

3 l = re.compile(r'(.+)[0-2](.*)') #对要匹配的格式先进行编译，并且整个过程中只编译一次

4 m =re.search(l, str)5 m1 = re.search(r'(.+)[0-2](.*)',str)6 #这是对上面两行的简写，这种写法每次匹配的时候都要进行一次匹配公式的编译，如何行数太多，就会使代码运行很慢

7 print(m.group())8 print(m1.group())

注: 由于反斜杠在Python和正则表达式中的影响，所以添加了 r 来使 字符串表示原生字符串，如果不使用　r   ,那么匹配时需要4个反斜杠，稍后有对反斜杠的解释

结果：

abc1def2ghi3jkl4mn

abc1def2ghi3jkl4mn

正则表达式的几种方法：

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

从头开始匹配，如果在开始位置匹配不成功则返回None

(flags：标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等)

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

匹配整个字符串，返回第一个成功匹配的，和match()的区别在于：开始位置匹配不成功也可继续匹配

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

将能够匹配到的字符串当做分割点对字符串进行分割成列表

( maxsplit：分割次数，maxsplit= 1,表示分割一次，默认为0 ，表示比限制次数)

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

找到所有匹配的字符子串 并以列表格式返回

(pos：指定字符串的起始位置，默认为0，endpos：指定字符串结束位置，默认为字符长度)

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

在字符串中找到所匹配到的子串，并作为一个迭代器返回

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

替换匹配到的字符，以字符串的形式返回

(repl：替换的字符串，也可为一个函数)

(count：模式匹配后替换的最大次数，默认0 表示替换所有的匹配)

re.subn(pattern,repl,string)

替换匹配到的字符，并返回一个替换了多少次的总数，以元组的形式返回

代码实现：

re.match():

1 importre2 str = 'abc1def2ghi3jkl4mn'

3 m = re.match('[0-9]', str)4 m1 = re.match('abc',str)5 print(m,m1.group())

结果：

None abc

re.search():

1 importre2 str = 'abc1def2ghi3jkl4mn'

3 m = re.search('[0-9]', str)4 print(m)

5 print(m.group())

结果：

1

re.split():

1 importre2 str = 'abc1def2ghi3jkl4mn'

3 m = re.split('[0-9]', str,)

4 print(m)

结果：

['abc', 'def', 'ghi', 'jkl', 'mn']

re.findall():

1 importre2 str = 'abc1def2ghi3jkl4mn'

3 m = re.findall('[0-9]', str)4 print(m)

结果：

['1', '2', '3', '4']

re.finditer

1 importre2 str = 'abc1def2ghi3jkl4mn'

3 m = re.finditer('abc|ef', str)4 print(m.__next__())5 print(m.__next__().group())

结果：

<_sre.sre_match object span="(0," match="abc">ef

re.sub():

1 importre2 str = 'abc1def2ghi3jkl4mn'

3 m = re.sub('[0-9]', '*', str, count=3)4 print(m)

结果：

abc*def*ghi*jkl4mn

re.subn():

1 importre2 str = 'abc1def2ghi3jkl4mn'

3 m = re.subn('[0-9]', '*', str)4 print(m)

结果：

('abc*def*ghi*jkl*mn', 4)

正则表达式的基本语法规则：

一般字符

匹配自身相对应的字符

.

匹配出换行符(\n)以外的任意字符

^

匹配字符串起始部分

$

匹配字符串终止部分

*

匹配0次或多次前面出现的正则表达式

+

匹配1 次或多次前面出现的正则表达式

？

匹配字符重复0次到1次前面出现的正则表达式

{N}

匹配N次前面出现的正则表达式

{N,}

匹配至少N次前面出现的正则表达式

{M,N}

匹配M~N次前面出现的正则表达式

[...]

匹配来自字符集的任意单一字符，如：[amk]匹配'a','m'或'k'

[^...]

不匹配此字符集出现的任何一个字符

[ x - y ]

匹配x~y范围中的任意单一字符

a | b

匹配 a 或 b

(...)

匹配括号内的表达式，将被括起来的表达式作为一个分组，可以使用索引单独取出

扩展表示法

(?....)

分组的不捕获模式，计算索引时会跳过这个分组(表示一个匹配不用保存的分组)

(? ilmsux)

分组中可以设置模式，ilmsux之中的每个字符代表一个模式

(?imx)

正则表达式包含三种可选标志：i,m,或x，值影响括号中的区域

(?-imx)

正则表达式关闭i,m,或x可选标志，只影响括号中的区域

(?:     )

类似(...),但不表示一个组

( ?-imx :    )

在括号中不使用i, m,或x 可选标志

(?imx :      )

在括号中使用i, m,或x 可选标志

(?#...)

注释

(?=...)

顺序肯定环视，表示所在位置右侧能够匹配括号内正则

(?!...)

顺序否定环视，表示所在位置右侧不能匹配括号内正则

(?<=...)

逆序肯定环视，表示所在位置左侧能够匹配括号内正则

(?

逆序否定环视，表示所在位置左侧不能匹配括号内正则

(?P=name)

引用该分组中的内容

(?P...)

为该分组起一个名字，可以用索引或名字去除该组名字

(?(id/name)Y|N)

如果分组提供的id或name(名称)存在，就返回正则表达式的条件匹配Y，如果不存在就返回N，N为可选项

特殊符号

\A

匹配字符串开始

\b

匹配一个单词的边界，一般是指单词和空格间的位置，例：'er\b'可以匹配‘never’中的'er',但不能匹配‘verb’中的‘er’

\B

匹配非单词边界

\w

匹配字母数字

\W

匹配非字母数字

\s

匹配任意空白字符，等价于[\t\n\r\f]

\S

匹配任意非空字符

\d

匹配任意数字，等价与[0-9]

\D

匹配任意非数字

\z

匹配字符串结束

\Z

匹配字符串结束，如果存在换行，只匹配到换行前的结束字符串

\G

匹配最后匹配完成的位置

\n,\t

匹配一个换行符，匹配一个制表符，等

\1...\9

匹配第n个分组的子表达式

\10

匹配第n个分组的子表达式，否则指的是八进制字符码的表达式

由于正则表达式使用反斜杠来转义字符，虽然Python正则表达式模块的转义是独立的，但是Python自身处理字符串时，反斜杠也是用于转义字符，就产生了双重转换。

例：匹配一个反斜杠字符需要将参数写成'\\\\'：

'\\\\'将被转义为'\\'

Python中的转义：

在python中使用正则表达式时要切记反斜线\具有两层转义功能，如果你要匹配一个反斜线本身时要注意它必须被转义两次。(除非你使用原始字符串，就是字符串前面加r)

Python遇到无法识别字符串中的\[，不会报错，而是将它原样"转交"给字符串： 字符串的表现层： \[ \\[， 字符串的概念层： \[ \[， 正则表达式的表现层： \[ \[， 正则表达式的概念层 ：[(非元字符) [(非元字符)

部分基本语法的代码实现：

1 importre2 s = '65432ab1cdefg'

3 m0 = re.findall('.', s)4 m1 = re.findall('.*', s) #匹配任意字符 * 表示匹配0个到多个表达式

5 m2 = re.findall('.+', s) #匹配任意字符 + 表示匹配1个到多个表达式

6 m8 = re.findall('[^\d].*', s) #[^...]匹配除...以外的字符

7 print(m0)8 print(m1)9 print(m2)10 print(m8)11

12 s1 = '6789_45 6a~bc@$deF'

13 m3 = re.findall('\S', s1) #\S 匹配非空的任意字符

14 m4 = re.findall('[a-zA-Z]+', s1) #匹配大小写字符

15 m5 = re.search('\d+', s1) #\d 匹配任意数字

16 m6 = re.search('^\d+$', '123455890') #如果这个字符串里有字母，那这行代码就会报错，因为\d+ 表示连续数字匹配

17 m7 = re.search('^.+$', '12345f5890') #. 表示匹配任意字符，所以这里的 ^ $可以从开头匹配到结尾

18

19 print(m3)20 print(m4)21 print(m5.group())22 print(m6.group())

function

结果：

['6', '5', '4', '3', '2', 'a', 'b', '1', 'c', 'd', 'e', 'f', 'g']

['65432ab1cdefg', '']

['65432ab1cdefg']

['ab1cdefg']

['6', '7', '8', '9', '_', '4', '5', '6', 'a', '~', 'b', 'c', '@', '$', 'd', 'e', 'F']

['a', 'bc', 'deF']6789

123455890

result

flags模式：可选标志位的具体参数：(可以通过or(|)指定多个标志位)

re.I

忽略大小写( 大小写不敏感模式 )

re.L

影响\w ,  \W ,  \b ,  \B ,  \s , \S ,  取决于 本地系统的语言设置(如：要处理法文文本，并用\w来处理文本，那必须是系统配置适当且 把本地化语言改为法文)

re.M

影响 ^,$, (此时，^，$ 不会被解释 )"^" 依然匹配字符串的开始和字符串中每行的开始。同样的， $ 元字符匹配字符串结尾和字符串中每行的结尾

re.S

相当于 .  并且包括换行符在内的任意字符  ( . 是不包括换行符的   )

re.U

表示特殊字符\w ,  \W ,  \b ,  \B ,  \d ,  \D ,  \s ,  \S  依赖于Unicode字符属性数据库

re.X

空白符被忽略，除非该空白符在字符类中或在反斜杠之后；并且允许你将注释写入 RE，这些注释会被引擎忽略；注释用 "#"号 来标识，不过该符号不能在字符串或反斜杠之后

实例实现：

1 importre2 str = 'abc\ndef\nghi'

3 m = re.search('^a.*i$', str, flags=re.S) #re.S 匹配包括换行的任意字符

4 print(m.group())5 m = re.search('^a.*$', str, flags=re.M) #^ $ 受 re.M影响，匹配行的开始和结尾

6 print(m.group())

s

结果：

abcdefghi

abc

result

几种匹配对象的方法：

x.group(m,...)

返回匹配字符串，默认m=0,可以获得第一个或者第m个括号的分组，多参数时将以元组的形式返回

x.groups()

返回一个包含所有小组字符串的元组

x.start(m)

默认m=0,返回第m个括号的字符串的开始索引

x.end(m)

默认m=0,返回第m个括号字符串的结束索引

x.span(m)

默认m=0,返回第m个括号字符串的开始索引和结束索引

实例：

1 importre2 str = 'abc1def2ghi3jkl4mn'

3 m = re.search(r'(.+)[0-2](.*)', str)4 print(m.group())5 print(m.group(2))6 print(m.start())7 print(m.end())8 print(m.span())

example

结果：

abc1def2ghi3jkl4mn

ghi3jkl4mn

018(0,18)

result

什么是贪婪匹配，什么是懒惰匹配

贪婪匹配：Python正则表达式默认的匹配，在匹配成功的前提下，正则表达式趋向于最大长度的匹配方式

非贪婪匹配(懒惰匹配)：在整个表达式匹配成功的前提下，尽可能少的匹配

贪婪词

惰性词

对贪婪的描述

？

？？

匹配前一个字符重复0次到1次

*

*？

匹配0次或多次

+

+？

匹配1次或多次

{n}

{n}？

匹配n次

{n , m}

{n , m}？

匹配n~m次，但至多不能超过m次

{n, }

{n, }？

匹配至少出现n次

实现：

1 importre2 str = 'aaaaabbbbb'

3 m = re.findall('.a*', str) #. 代表匹配除换行符的所有字符

4 m1 = re.findall('.a*?', str)5 m2 = re.findall('.b{2,}', str)6 m3 = re.findall('.b{2,}?', str)7 print(m)8 print(m1)9 print(m2)10 print(m3)

import

结果：

['aaaaa', 'b', 'b', 'b', 'b', 'b'] #一次就匹配完了a

['a', 'a', 'a', 'a', 'a', 'b', 'b', 'b', 'b', 'b']

['abbbbb']

['abb', 'bbb']

result

正则表达式的简单匹配例子：

例1，匹配电话号码：

1 importre2 phone_str = 'my phone number is 18380364920'

3 m = re.search('(1)([34578]\d{9})', phone_str) #(1)表示第一个分组，[34578]表示第二个数字能匹配的数字 ，\d相当于[0-9]

4

5 ifm:6 print(m.group())

phone

结果：

18380364920

result

例2，简单匹配email：

1 importre2 email = '2536vera.yin@qq.com'

3 m = re.search(r'[0-9.a-z]{1,26}@[0-9.a-z]{0,20}.[0-9a-z]', email)4 print(m.group())

email

结果：

2536vera.yin@qq.com

View Code

例3，简单匹配IP V4

1 importre2 defai():3 str = input('ipv4地址：')4 m = re.findall('^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$', str)5 ifm:6 print('ip 有效:', m)7 else:8 print('ip 无效:', m)9 ai()10

11 ai()

IPv4

结果：

ipv4地址：192.168.3.22ip 有效: ['192.168.3.22']

ipv4地址：223.432.44.3ip 无效: []

ipv4地址：

result