1 正则表达式

正则表达式就是用来检测字符串是否满足某种规则的工具
例如：

• 1.账号是手机号/邮箱：位数/组成等
• 2.到拉萨开！发金额。看看是？打算离，开啥都看
• 3.某些话替换成**等。

a.正则语法
b.python对正则表达式的支持，提供了一个内置模块：re
fullmatch(正则表达式，字符串)：判断字符串是否符合正则表达式的规则。

2 正则符号

2.1 单个字符

1）"."：匹配任意字符，一个"."只能匹配一位

# 匹配一个字符串，只有一位字符并这个字符是任意字符
re_str = r'.'
result = fullmatch(re_str, 'a')
print(result)

2）"\w"：匹配字母、数字、下划线，一个"\w"只能匹配一位

匹配一个字符串，前三位分别是abc，最后两位是字母数字或者下划线。一个\w只能匹配一位
re_str = r'abc\w\w'
result = fullmatch(re_str, 'abc1_')
print(result)

3）"\s"：匹配空白字符（空白指空格、制表符和回车等所有能产生空白的字符）,一个"\s"只能匹配一位

re_str = r"\w\w\w\s."
result = fullmatch(re_str, 'hu2\n?')
print(result)

4）"\d"：匹配一个数字字符

匹配一个字符串，前三位是数字字符，最后一位是任意字符
re_str = r'\d\d\d.'
result = fullmatch(re_str, '782L')
print(result)

5）"\b"：检测是否是单词边界（单词的开头、单词的结尾）
注意：正则中遇到\b，匹配时先不管，匹配成功后再回头看\b位置是够是单词边界。

# 匹配一个字符串，前四位是when，第五位是空白，空白后面是where。并且第四位n的后面是个边界
re_str = r'when\b\swhere'
result = fullmatch(re_str, 'when where')
print(result)

6）"^"：检测字符串是否以给定的正则表达式开头

# 匹配一个字符串，是否以两个数字开头
re_str = r'^\d\d..'
result = fullmatch(re_str, '23s#')
print(result)

7）"$"：检测字符串是否以给定的正则表达式结束

re_str = r'..\d\d$'
result = fullmatch(re_str, 's&56')
print(result)

8）"\W"：匹配一个非字母、数字、下划线的字符

re_str = r'\W\w'
result = fullmatch(re_str, '&5')
print(result)

9）"\S"：匹配非空白字符

re_str = r'\S\w\w\w'
result = fullmatch(re_str, 'asdf')
print(result)

10）"\D"：匹配一个非数字字符

11）"\B"：检测非单词边界

2.2 匹配次数

1）"[]"：匹配中括号中出现的任意字符，一个中括号匹配一个字符

# 匹配一个三位的字符串，其中第一位是a或b或c，后两位是数字
re_str = r'[abc]\d\d'
result = fullmatch(re_str, 'a45')
print(result)
result = fullmatch(re_str, 'c89')
print(result)

# -在正则中的中括号中的应用：如果将减号放到两个字符之间代表的是谁到谁，如果想要表示'-'本身，就放在开头或结尾。
# 要求一个字符串中的第一个是1-8中的一个，后面两位是小写字母
# [1-8]：代表的字符集是：12346578
# [-18]or[18-]:代表的字符集是18-
re_str = r'[1-8][a-z][a-z]'
result = fullmatch(re_str, '8jj')
print(result)

2）[^字符集]：匹配不在[]字符集中的任意一个字符

# 匹配一个四位的字符串，第一位不是大写字母，后三位是abc
re_str = r'[^A-Z]abc'
result = fullmatch(re_str, 'aabc')
print(result)

3）"*"：匹配0次或者多次

# 匹配一个字符串，最后一位是b，b前面有0个或者多个a
re_str = r'a*b'
result = fullmatch(re_str, 'aaaab')
print(result)

4）"+"：匹配1次或者多次（至少一次）

# 判断一个字符串是否是无符号的整数
re_str = r'[1-9]+\d*'
result = fullmatch(re_str, '120')
print(result)

注意：次数相关的操作，都是约束的次数符号的前一个字符

5）"?"：匹配0次或者一次

re_str = r'@?\d+'
result = fullmatch(re_str, '@16723')
print(result)

# 判断一个字符串是否是整数（包含正整数和负整数）
# +200，-120，-99
re_str = r'[+-]?[1-9]+\d*'
result = fullmatch(re_str, '8')
print(result)

6）"{N}"：匹配N次

re_str = r'\d{3}'
result = fullmatch(re_str, '888')
print(result)

7）"{N,}"：至少匹配N次

re_str = r'\w{4,}'
result = fullmatch(re_str, '8888')
print(result)

8）"{,N}"：至多匹配N次

re_str = r'\w{,4}'
result = fullmatch(re_str, '88')
print(result)

9）"{M,N}"：匹配至少M次，至多N次（N>M）

re_str = r'\w{6,8}'
result = fullmatch(re_str, '8888888')
print(result)

2.3 分之和分组

1）"|"：分之（相当于逻辑运算中的or）

# 匹配一个字符串是三个字母或者是三个数字
re_str = r'[a-zA-Z]{3}|\d{3}'
result = fullmatch(re_str, 'abc')
print(result)

# \d{3}[a-z]是分之的第一个条件，[A-F]{3}是分之的第二个条件
re_str = r'\d{3}[a-z]|[A-F]{3}|'
result = fullmatch(re_str, 'AEF')
print(result)

# 正则中的分之有短路操作：如果使用|去连接多个条件，前面的条件已经匹配出结果，那么久不会使用后面的条件再去匹配
# 练习：写一个正则表达式，能够匹配出字符串中所有的数字（包括整数和小数）
# 'abc12.5hhh60,30.2kkk9nn0.12'
re_str = r'[1-9]\d*|\d+[.]\d+'
print(findall(re_str, 'abc12.5hhh60,30.2kkk9nn0.12'))
re_str = r'\d+[.]\d+|[1-9]\d*'
print(findall(re_str, 'abc12.5hhh60,30.2kkk9nn0.12'))

2）分组
a.分组

# 通过加()来对正则条件进行分组
# 两位数字两位字母出现三次
re_str = r'([a-z]{2}\d{2}){3}'
print(fullmatch(re_str, 'ac23sd54sf89'))

# 匹配一个字符串，按照一个数字一个字母的规律出现多次
re_str = r'(\d[a-z])+'
print(fullmatch(re_str, '9s6s3s8a4f'))

b.重复

# 可以通过 \数字 来重复匹配前面的括号中匹配的结果
re_str = r'(\d{2}[A-Z])=%\1'
print(fullmatch(re_str, '12B=%12B'))
re_str = r'(\d{3})-(\w{2})\1{2}\2'
print(fullmatch(re_str, '132-aa132132aa'))

c.捕获

# 按照完整的正则表达式去匹配，只捕获()中的内容。只有在findall中有效
re_str = r'a(\d{3})b'
print(fullmatch(re_str, 'a786b'))
print(findall(re_str, 'a786b'))

3 正则中的转义

• 1.正则表达式中的转义和字符串中的转义字符没有任何关系。
  在python中的字符串前加r阻止的是字符串转义，不能阻止正则表达式的转义。

• 2.在正则表达式中，可以通过在有特殊意义的符号前加''来表示符号本身。
  + . * ? \ ( ) [ ] ^ $ |

• 注意：
  a.减号只有在中括号中的两个字符之间才有特殊意义，一般情况下不用转义。
  b.如果特殊符号是放在中括号中作为字符集的内容，那么出了减号在两个字符之间外和'',都不需要转义。
  c.''在哪里都要转义，'^'放在中括号的最前面需要转义。

re_str = r'a\+'
print(fullmatch(re_str, 'a+'))

re_str = r'\\w-a'
print(fullmatch(re_str, '\w-a'))

re_str = r'\(\d{3}'
print(fullmatch(re_str, '(123'))

re_str = r'[.\\?*]abc'
print(fullmatch(re_str, '\\abc'))

输出结果为：

<_sre.SRE_Match object; span=(0, 2), match='a+'>
<_sre.SRE_Match object; span=(0, 4), match='\\w-a'>
<_sre.SRE_Match object; span=(0, 4), match='(123'>
<_sre.SRE_Match object; span=(0, 4), match='\\abc'>

4 re模块

1.compile(正则表达式)：将正则表达式转换成正则表达式对象

import re

re_str = r'\d+'
re_object = re.compile(re_str)
print(re_object)
# 不转成对象，调用相应的函数
# re.match(re_str, '78s')
# 转换成对象，调用相应的方法
print(re_object.match('78s'))

输出结果为：

re.compile('\\d+')
<_sre.SRE_Match object; span=(0, 2), match='78'>

2.match(正则表达式，字符串)

# 判断字符串的开头是否能够和正则表达式匹配
# 返回值是匹配结果，如果匹配成功返回匹配对象，否则返回None
re_str = r'abc\d{3}'
match1 = re.match(re_str, 'abc123456')
match2 = re.fullmatch(re_str, 'abc234')
print(match1)
print(match2)

输出结果为：

<_sre.SRE_Match object; span=(0, 6), match='abc123'>
<_sre.SRE_Match object; span=(0, 6), match='abc234'>

• a.匹配到的范围。匹配结果字符的下标范围：(起始下标，结束下标) --- 结束下标取不到

print(match1.span())
# 获取起点
print(match1.start())
# 获得终点
print(match1.end())

re_str = r'(\d{3})\+([a-z]{2})'
match1 = re.match(re_str, '234+hjaaaaa')
print(match1)
print(match1.span())
# 在匹配结果中，获取第1个分组的范围
print(match1.span(1))
# 在匹配结果中，获取第2个分组的范围
print(match1.span(2))

# 在匹配结果中，获取第2个分组的起始下标
print(match1.start(2))

输出结果为：

(0, 6)
0
6
<_sre.SRE_Match object; span=(0, 6), match='234+hj'>
(0, 6)
(0, 3)
(4, 6)
4

• b.获取匹配结果对应的字符串
  注意：group参数，用来指定分组对应的相应的结果

print(match1.group())
print(match1.group(1))
print(match1.group(2))

输出结果为：

234+hj
234
hj

• c.获取被匹配的原字符串

print(match1.string)

输出结果为：

234+hjaaaaa

3.search(正则表达式，字符串)
在字符串中去查找第一个满足正则表达式要求的子串，如果找到了就返回匹配对象，找不到返回None。

search1 = re.search(r'\d+aa', 'hello 78aabc world')
print(search1)
if search1:
    print(search1.span())

输出结果为：

<_sre.SRE_Match object; span=(6, 10), match='78aa'>
(6, 10)

练习：使用search将一个字符串中所有的数字字符串全部找到。。。

# '工资是10000元，年龄是18岁，身高是：180，颜值100分'
str1 = '工资是10000元，年龄是18岁，身高是：180，颜值100分'
re_str = r'[1-9]\d*'
search1 = re.search(re_str, str1)
while search1:
    print(search1.group())
    end = search1.end()
    str1 = str1[end:]
    search1 = re.search(re_str, str1)

输出结果为：

10000
18
180
100

4.spilt(正则表达式，字符串)
按满足正则表达式的子串去切割字符串，返回值是列表。

str1 = '窗前明月光，疑是地上霜。举头望明月，低头思故乡！'
result = re.split(r'[，。,！!]', str1)
print(result)

输出结果为：

['窗前明月光', '疑是地上霜', '举头望明月', '低头思故乡', '']

5.sub(正则表达式，替换字符串，被替换的字符串)

word = '你丫是傻叉吗？我操你大爷的.Fuck you'
result = re.sub(r'傻叉|操|Fuck|煞笔', '*', word)
print(result)

输出结果为：

你丫是*吗？我*你大爷的.* you

6.findall(正则表达式，字符串)
获取字符串中所有满足正则表达式的子串，返回值是列表。

result = re.findall(r'[a-z]+', '%%#si%chuang,你好')
print(result)

输出结果为：

['si', 'chuang']