python正则表达式(re)

1、知识点导图

1、正则表达式简单介绍及意义
2、正则表达式的基本语法
3、正则表达式的七种武器
4、正则表达式的常见语法

2、正则表达式的意义

什么是正则表达式

正则表达式并不是Python的一部分。正则表达式是用于处理字符串的强大工具，拥有自己独特的语法以及一个独立的处理引擎，效率上可能不如str自带的方法，但功能十分强大。得
益于这一点，在提供了正则表达式的语言里，正则表达式的语法都是一样的，区别只在于不同的编
程语言实现支持的语法数量不同；但不用担心，不被支持的语法通常是不常用的部分。如果已
经在其他语言里使用过正则表达式，只需要简单看一看就可以上手了。
Python的正则表达式的模块是 ‘re’,它的基本语法规则就是指定一个字符序列

正则表达式的大致匹配过程

依次拿出表达式和文本中的字符比较，如果每一个字符都能匹配，则匹成功；一旦有匹配不
成功的字符则匹配失败。如果表达式中有量词或边界，这个过程会稍微有一些不同，但也是很
好理解的，看下图中的示例以及自己多使用几次就能明白。

3、正则表达式的基本语法

1、 字符

字符

功能

一般字符 匹配自己
\ 转义字符
[] 字符集，对应的位置可以使字符集里的任意字符或范围,使用特殊符号需要进行转义
[^] 表示匹配非^后边内容 [^abc]表示匹配非abc的内容
| 将两个规则并列起来，以‘|’连接，表示只要满足其中之一就可以匹配
| 注意 |匹配两边整条规则，加特技需要‘(?: )’包起来，如：I have a (?:dog

2、预定义字符集（可以写在字符集中）

字符

功能

. 匹配除\n外所有字符，加特技需要加S，就可以包括\n了(r‘.+’ , str , re.S)
\d 数字[0-9]
\D 非数字[^\d]
\s 间隔字符[<空格>\t\r\n\f\v]
\S 非空白间隔字符[^\s]
\w 单词字符[a-zA-Z]
\W 非单词字符[^\w]

3、数量词

字符

功能

• 匹配前一个字符0次或者无限次 a*
• 匹配前一个字符1次或者无限次a+
  ？ 匹配前一个字符0次或者1次a?
  {m} 匹配前一个字符m次 a{m}
  {m-n} 匹配前一个字符m到n次 a{m-n}，最少m次需要{m,}
  数量词? 使匹配以非贪婪模式下进行 a*?、a+?

4、边界匹配（不消耗待匹配的字符串中的字符）

字符

功能

^ 匹配字符串开头，多行模式下匹配每一行开头^abc

|匹配字符串的结尾，多行模式下匹配每一行结尾abc
|匹配字符串的结尾，多行模式下匹配每一行结尾abc

\A|仅匹配字符串的开头 \Aabc
\Z|仅匹配字符串的结尾 abc\Z
\b |匹配\w和\W之间的
\B|[^/b]

5、逻辑、分组

字符

功能

| 左右表达式任意匹配一个，默认左边开始
(….) 分组，从表达式左边起，遇到的第一个为1，依次加1
(?P…) 分组除了原名外，增加别名name (?Pabc){2} =abcabc
\ 引用分组编号为number的组匹配的字符(\d)abc\1 = 1abc1
(?P = name) 引用别名为name的分组匹配的字符串

贪婪模式的例子
pat = re.compile(“ab*”)
str1 = pat.findall(“abbbbbbbbb”)
print(str1)

---

[‘abbbbbbbbb’]1
2
3
4
5
6

非贪婪模式的例子
pat = re.compile(“ab*?”)
str1 = pat.findall(“abbbbbbbbb”)
print(str1)

---

[‘a’]1
2
3
4
5
6

反斜杠的困扰
1.表示\d可以用r”\d”代替”\d”
2.表示\可以用r”\”替代”\\”

re模块-正则的七个方法

match(pat, orginStr[, flag])
m = re.match(pat, orginStr[, flag])
m.string1
2

match方法解释
1.从原始字符串第一个字符开始,匹配正则的规则
2.如果不是从第一个字符开始就匹配不到
3.参数1：正则表达式
4.参数2：原始的字符串
5.参数3：匹配模式(可选参数)

match方法返回值的属性
1.m.string: 匹配时使用的文本
2.m.re: 匹配时使用的Pattern对象
3.m.pos: 文本中正则表达式开始搜索的索引
4.m.endpos: 文本中正则表达式结束搜索的索引
5.m.lastindex: 最后一个被捕获的分组在文本中的索引
6.m.lastgroup: 最后一个被捕获的分组的别名

match方法返回值的方法
1.re.group(group1…)：获得一个或多个分组截获的字符串;指定多个参数时将以元组形式返回,group1可以是编号,也可以是别名
2.re.groups([default])：以元组的形式返回全部分组捕获的字符串,如果没有找到返回default设置的值,默认返回None
3.groupdict([default])：返回以有别名的组的别名为键、以该组截获的子串为值的字典，没有别名的组不包含在内
4.start([group])：返回指定的组截获的子串在string中的起始索引(子串第一个字符的索引).group默认值为0
5.end([group])：返回指定的组截获的子串在string中的结束索引(子串最后一个字符的索引+1).group默认值为0
6.span([group])：返回(start(group),end(group))
7.expand(template)：将匹配到的分组代入template中然后返回

search()

compile
pat = re.compile(“ab*?”) # 得到一个正则表达式的对象1

compile(pat[,flag])
1.第一个参数是正则表达式
2.第二个参数是匹配模式

compile匹配模式

模式

详解

re.I/re.IGNORECASE 忽略大小写
re.M/re.MULTILINE 多行模式,改变’^’和’$’的行为
re.S(re.DOTALL) 点任意匹配模式，改变’.’的行为
re.L(re.LOCALE) 使预定字符类 \w \W \b \B \s \S 取决于当前区域设定
re.U(re.UNICODE) 使预定字符类 \w \W \b \B \s \S \d \D
re.X(re.VERBOSE) 详细模式,可以是多行,忽略空白字符,可以加入注释

escape(str)
re.escape(“\d”) –> \d1

escape方法详解
1.用于将元字符串进行转义后再返回
2.感觉没有半点用

findall()

split()

sub()\subn()

purge()：清空缓存中的正则表达式,等待验证,有点坑
re.purge() –> 返回值是None1

Pattern对象
pattern = re.compile(“正则表达式”)1

Pattern对象的属性
1.pattern: 编译时用的表达式字符串
2.flags: 编译时用的匹配模式,数字形式
3.groups: 表达式中分组的数量
4.groupindex: 以表达式中有别名的组的别名为键、以该组对应的编号为值的字典,没有别名的组不包含在内

Pattern对象的方法

1. match(string[, pos[, endpos]]) | re.match(pattern, string[, flags])
   1.从第一个字符开始匹配
   2.string是要匹配的字符串
   3.pos是起始匹配的位置
   4.endpos：终止匹配的位置
   5.返回值是一个Match对象

match方法例子
import re
p = re.compile(r’(\w+) (\w+)(?P.*)’, re.DOTALL)

print(“p.pattern:”, p.pattern)
print(“p.flags:”, p.flags)
print(“p.groups:”, p.groups)
print(“p.groupindex:”, p.groupindex)

output

p.pattern: (\w+) (\w+)(?P.*)

p.flags: 16

p.groups: 3

p.groupindex: {‘sign’: 3}1

2
3
4
5
6
7
8
9
10
11
12
13

1. search(string[, pos[, endpos]]) | re.search(pattern, string[, flags])
   1.从字符整个字符串开始搜索匹配
   2.string是要匹配的字符串
   3.pos是起始匹配的位置
   4.endpos：终止匹配的位置
   5.返回值是一个Match对象

search方法例子

encoding: UTF-8

import re

将正则表达式编译成Pattern对象

pattern = re.compile(r’world’)

使用search()查找匹配的子串，不存在能匹配的子串时将返回None

这个例子中使用match()无法成功匹配

match = pattern.search(‘hello world!’)

if match:
# 使用Match获得分组信息
print match.group()

输出

world1

2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

1. split(string[, maxsplit]) | re.split(pattern, string[, maxsplit])
   1.从字符整个字符串开始搜索匹配
   2.string：要匹配的字符串
   3.maxsplit：指定最大分割次数，不指定将全部分割
   4.返回值是一个分割的列表

split方法例子
import re

p = re.compile(r’\d+’)
list1 = p.split(‘one1two2three3four4’)
print(list1)

output

[‘one’, ‘two’, ‘three’, ‘four’, ”]1

2
3
4
5
6
7
8

1. findall(string[, pos[, endpos]]) | re.findall(pattern, string[, flags])
   1.从开头到末尾匹配字符串
   2.string是要匹配的字符串
   3.pos是起始匹配的位置
   4.endpos：终止匹配的位置
   5.返回一个找寻到的列表

findall
import re

p = re.compile(r’\d+’)
list1 = p.findall(‘one1two2three3four4’)
print(list1)

output

[‘1’, ‘2’, ‘3’, ‘4’]

1
2
3
4
5
6
7
8
9

1. finditer(string[, pos[, endpos]]) | re.finditer(pattern, string[, flags])
   1.过滤出想要的数据，返回值是一个迭代器

finditer方法例子
import re

p =re.compile(r’\d+’)
for m in p.finditer(‘one1two2three3four4’):
print m.group()

output

1 2 3 41

2
3
4
5
6
7
8

1. sub(repl, string[, count]) | re.sub(pattern, repl, string[, count])
   1.利用repl字符串替换原有string字符串
   2.第一个参数repl：要替换的字符串
   3.第二个参数string：原始字符串
   4.第三个参数count：count用于指定最多替换次数,不指定时全部替换
   5.返回值：返回一个字符串

sub方法
import re

p = re.compile(r’(\w+) (\w+)’)
s = ‘i say, hello world!’

print p.sub(r’\2 \1’, s)

def func(m):
return m.group(1).title() + ’ ’ + m.group(2).title()

print p.sub(func, s)

output

say i, world hello!

I Say, Hello World!1

2
3
4
5
6
7
8
9
10
11
12
13
14
15

组与Match对象

常见的正则表达式

QQ表达式
“[1-9]\d{4,10}”1

QQ号规则
1.首先扣扣号开头不能为0；
2.QQ号必须大于5且小于11(或12,13,QQ号最长位)

手机号表达式

平常手机号

“1[34578]\d{9}”

手机号码后5位相同

“1[34578]\d{4}(\d)\1{4}”1
2
3
4
5

手机号码规则
1.手机号位数为11位
2.开头为1,第二位为3或4或5或7或8

邮箱表达式
“[\w-.]+\@(?:[\w-]+.)+[a-z]{2,3}”1

邮箱规则
1.@符号前面的可以为字母,数字,下划线,中划线,或’.’
2.@后面的可以是xxx.com、xxx.cn、xxx.com.cn

用户名表达式
“[a-zA-z]\w{0,9}”1

用户名规则
1.必须以字母开头，长度在10位以内

密码表达式
“.{6,16}”1

密码规则
1.任意字符，6~16位