本文章最初发布在 XJHui’s Blog，未经允许，任何人禁止转载！

注意：最新修改版本已发布在这里，点击前往查看！

re模块

正则表达式

正则表达式：被用来检索（主要用途）、替换符合某个规则的字符
re模块和正则的关系：先有正则后有re模块（C语言编写，速度快）， re是python中用来实现正则功能的模块

mach()

匹配符合正则表达式规则的字符串 mach(pattern,data,flag=0)

案例（无标志位flag）：

import re  # 导入re模块

strData = 'hello world'  # 字符串数据
res = re.match('h', strData)  # 两个参数分别代表：正则表达式、字符串数据
if res:
    print('匹配成功')
    print(res.group())  # 使用res.group()返回匹配结果
else:
    print('匹配失败')

运行结果：

案例（有标志位flag）：

import re

strData = 'hello world'
res = re.match('H', strData, re.I)  # 第三个参数为标志位：re.I代表大小写不敏感
if res:
    print('匹配成功')
    print(res.group())  # 如果匹配失败，使用res.group()则会报错
else:
    print('匹配失败')

运行结果：

标志位可选参数：

group()：

匹配结果会返回到group中

下标：
- group(0)（0可省略）：匹配结果
- group(1)：返回第一组匹配结果
- groups()：返回所有组匹配结果

案例：

import re
  
  strData = 'Python is the best language in the world'
  res = re.match('(.*) is (.*?) .*', strData, re.I)  # 第三个参数为标志位：re.I代表大小写不敏感
  if res:
      print('匹配成功')
      print('res.groups()：', res.groups())  # groups(陪陪)
      print('res.group()：', res.group())
      print('res.group(0)：', res.group(0))
      print('res.group(1)：', res.group(1))
      print('res.group(2)：', res.group(2))
  else:
      print('匹配失败')

运行结果：

注意：
- 有几组匹配结果的判断方法后面会讲解
- group(0)、group()效果是一致的
  compile()

将正则表达式编译成一个正则表达式对象，以提高效率

为什么会提高效率？当使用match匹配时，python每次都会将正则表达式转换成对象，而使用compile只需要转换一次

案例：匹配4位数字

match方法：

import re

htmlTag = '12345677'
pattern = '\d{4}'  # 固定个数可使用{num}表示，下面具体会讲解
res = re.match(pattern, htmlTag)
print(res.group())

运行结果：

compile方法：

import re

reobj = re.compile('\d{4}')
res = reobj.match('12345677')
print(res.group())

运行结果：

注意：
- 两种方法结果是一致的，只是速度有差别
- 下文案例主要使用match方法讲解，但推荐使用compile方法

search()

全文查找，找到一个就返回，而match必须是从开头开始匹配

import re

data = 'I love China!'
pattern = 'China'
res = re.search(pattern, data)
print(res)
print(res.group())

运行结果：

findall()

将所有匹配结果保存到列表中返回，而search只是返回第一个

import re

data = 'I love China, China!'
pattern = 'China'
res = re.findall(pattern, data)
print(res)

运行结果：

sub()

将匹配到的数据进行替换 re.sub(pattern,replace,data,count,flags=0)

import re

data = 'hello world'
pattern = 'l'
res = re.sub(pattern, 'L', data, 2)  # 将匹配的字符换成L，并限制替换次数为2
print(res)

运行结果：

split()

分隔字符串（前面有讲过），最后返回一个列表

import re

data = '1,2,3,4,5,6'
res = re.split(',', data)
print(res)

运行结果：

常用匹配规则

匹配字符

.（点）

匹配任意1个字符（除了换行符\n）

案例：匹配 ‘李娜’

import re

name = '李娜'  # 数据
pattern = '李.'  # 正则表达式
res = re.match(pattern, name)  # match方法
print(res.group())

运行结果：

[]

匹配括号中的任意一个字符
1
2
3
4
5
6
import re

name = 'elloh'
pattern = '[he]'
res = re.match(pattern, name)
print(res.group(0))
运行结果：

注意：[a-z]、[A-Z]、[0-9]语法是正确的，甚至可以写成[a-zA-Z0-9]

\d、\D

匹配一个数字（0-9）、一个非数字

案例1（\d，匹配一个数字）：

import re

data = '1123aaa'
pattern = '\d'
print(re.match(pattern, data).group())

运行结果：

案例2（\D，匹配一个非数字）：

import re

data = 'a1123a'
pattern = '\D'
print(re.match(pattern, data).group())

运行结果：

\s、\S

匹配一个空字符、一个非空字符

\s（匹配一个空字符）

import re

data = ' a1123a'
pattern = '\s'
print(re.match(pattern, data).group())

\S（匹配一个非空字符）

import re

data = 'a1123a'
pattern = '\S'
print(re.match(pattern, data).group())

\w、\W

匹配一个单词字符（0-9、a-z、A-Z、_）、一个非单词字符

import re

data = 'a1123a'
pattern = '\w'
print(re.match(pattern, data).group())

运行结果：

import re

data = ' a1123a'
pattern = '\W'  # 匹配一个空字符
print(re.match(pattern, data).group())

匹配字符数量

匹配字符数量的符号满足前一个匹配规则的次数

满足前一个匹配规则0或无限次

案例1：

1
2
3

import re

print(re.match('[A-Z]*', 'MAAA').group())

运行结果：

综合案例：匹配符合规范的python变量名（不能以数字开头，只能包含字母和数字）

import re

pattern = '[a-zA-Z_]+\w*'  # 正则表达式（匹配字符要搭配一个数量），a-zA-Z0-9不需要加任何分隔符
dataList = ['1nihao', 'nihao', 'Test111', 'Tes t_', 'Test_t', '**test']  # 测试数据
for item in dataList:  
    try:  # 异常处理
        res = re.match(pattern, item)
        print(res.group())
    except AttributeError: 
        pass

运行结果：

满足前一个匹配规则至少1次

1
2
3

import re

print(re.match('[a-bA-B]+', 'aabbcd').group())  # 注意：[a-b]表示[ab]，其余同理

运行结果：

{,max}、{min,}、{min,max}，？

满足前一个匹配规则最多max次、最少min次、min-max次，0-1次

案例：

import re

print('\d{,5}', re.match('\d{,5}', '12344555a1').group())  
print('\d{1,}', re.match('\d{1,}', '12344555a1').group())
print('\d{1,5}', re.match('\d{1,5}', '12344555a1').group())

运行结果：

注意：

?的含义和{0,1}相同
固定次数为5，可以使用{5}来实现

综合案例：匹配qq邮箱（数字@qq.com）

pattern = '\d{1,}@qq.com'
dataList = ['123@qq.com', '123@qq1.com', 'a123@qq.com', '123@qq.cn']
for item in dataList:
    try:
        res = re.match(pattern, item)
        print(res.group())
        pass
    except AttributeError:
        pass

运行结果：

原生字符串

python读取字符串时会对\后面的字符自动进行转义，从而引起一些问题

引入案例：打印路径 ‘d:\next\1day\4class’
1
2
str = 'd:\python\next\1day\4class'
print(str)
运行结果：

解决方法：在所有的\前面再添加一个转义字符\
1
2
str = 'd:\\python\\next\\1day\\4class'
print(str)
运行结果：
匹配路径：’d:\\test’
- 直接匹配：
  1
  2
  3
  import re
  
  print(re.match('d:\\test', 'd:\\test').group())
  运行结果：
  
  注意：在匹配时，正则表达式中会被转义成 ‘d:\test’ 故不能与 ‘d:\test’ 匹配成功
- 解决方法1：
  1
  2
  3
  import re
  
  print(re.match('d:\\\\test', 'd:\\test').group())
  运行结果：
  
  注意：
  - 为什么要加两个\：因为匹配串中每个\都需要一个\去取消转义
  - 虽然上图结果是 ‘d:\test’ 但匹配成功的字符串肯定是 ‘d:\test’，因为只有 ‘d:\\test’ 打印出来才是 ‘d:\test’ ：
- 解决方法2：
  1
  2
  3
  import re
  
  print(re.match(r'd:\\test', 'd:\\test').group()) # 保证两个串中\个数一致，在正则前面加r
  运行结果：
  
  注意：如果你疑惑为什么少了个\，就去看解决方法1中的注2

匹配开头结尾

匹配字符串的开头

1
2
3

import re

print(re.match('^P.*', 'Python is good').group())

运行结果：

匹配字符串的结尾

1
2
3

import re

print(re.match('\d{1,13}@qq.com$', '1231@qq.com').group())

运行结果：

分组匹配

|

匹配左右任意一个表达式
1
2
3
4
5
import re

pattern = '[1-9]?\d$|100'
print(re.match(pattern, '78').group())
print(re.match(pattern, '100').group())
运行结果：

上面的正则表达式可分别匹配78、100，为便于理解，可将正则表达式分别如下：

(ab)

将括号中的字符作为一个分组

import re

# 匹配电话号码 ****-12345678
pattern = '(\d{4,4})-(\d{8,8})'
print(re.match(pattern, '0101-12334234').group(0))
print(re.match(pattern, '0101-12334234').group(1))  # 分组后的第一组
print(re.match(pattern, '0101-12334234').group(2))  # 分组后的第二组

运行结果：

注意：每一个()对应一个匹配结果

\num

引用前面分组的字符串

htmlTag = '<html><h1>你好啊</h1></html>'
pattern = r'<(.+)><(.+)>(.+)</\2></\1>'  # /2、/1分别代表前面分组2（h1）和分组1（html），注意r可以加在''前面
res = re.match(pattern, htmlTag)
print(res.group(0))
print(res.group(1))
print(res.group(2))
print(res.group(3))

运行结果：

起别名：?P<名字> 使用别名：(?P=名字)

import re

# 匹配html
htmlTag = '<html><h1>你好啊</h1></html>'
pattern = r'<(?P<html>.+)><(?P<h1>.+)>(.+)</(?P=h1)></(?P=html)>'
res = re.match(pattern, htmlTag)
print(res.group(0))
print(res.group(1))
print(res.group(2))
print(res.group(3))

运行结果：

贪婪模式

默认情况下会尽可能多的去匹配满足条件的数据

案例：

import re

data = '123456'
pattern = '\d{3,6}'
pattern_no = '\d{3,6}?'  # 非贪婪只需要在最后添加一个？
print('贪婪：', re.match(pattern, data).group())  # 默认为贪婪模式
print('非贪婪：', re.match(pattern_no, data).group())

运行结果：

注意：非贪婪模式会尽可能少的去匹配满足条件的数据，非贪婪模式中的？其实就是前面匹配字符数量中的？

优先级问题（极易错）：
1
2
3
4
content = 'aacbacbc'
pattern = re.compile('a.*?b')
result = re.search(pattern,content)
print(result.group())
运行结果：

答案为什么不是acb？因为最先开始的匹配拥有最高的优先权，即：

匹配到的第一个a具有最高优先权，只要之后没有发生匹配失败的情况，它就会一直匹配下去，直到匹配成功，感谢 Siro阿希！

后记

好啦，python基础的学习到这里就结束了！

后面会更新linux的学习笔记，期待吧！一起加油！

终于成功入门了一次，hahaha…

不足之处，欢迎留言，会及时回复，及时更正！

创作不易，感谢支持！

re模块

正则表达式

mach()

compile()

search()

findall()

sub()

split()

常用匹配规则

匹配字符

匹配字符数量

原生字符串

匹配开头结尾

分组匹配

贪婪模式

后记