1.正则表达式

1.1定义

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

例如：

1.账号是手机号/邮箱/多少位由什么东西组成等.....
2.脏话替换成*等.....

1.2正则语法

python对正则表达式的支持，提供了一个内置模块：refullmatch(正则表达式, 字符串)：判断整个字符串是否符合正表达式规则

1.2.2 点 . 匹配任意字符

匹配一个字符串，字符串只有一位字符并这个字符是任意字符

re_str = r'.'
result = fullmatch(re_str, 'a')
print(result)

匹配一个字符串，只有两位字符并这每个字符都是任意字符

re_str = r'..'
result = fullmatch(re_str, 'an')
print(result)

匹配一个字符串，前三位分别是abc，最后一位是任意字符

re_str = r'abc.'
result = fullmatch(re_str, 'abc%')
print(result)

1.2.2 \w

匹配字母、数字、下划线

匹配一个字符串，前三位分别是abc,最后两位是字母数字或者下划线

re_str = r'abc\w\w'
result = fullmatch(re_str, 'abc2g')
print(result)

1.2. 3 \s

匹配空白字符（空白指空格、制表符(\t)和回车(\n)等所有能产生空白的字符）

匹配一个字符串，前三位是字母数字下划线第四位是一个空白字符最后一位是任意字符

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

1.2.4 \d

匹配一个数字字符

匹配一个字符串，前三位是数字字符，最后一位是任意字符

re_str = r'\d\d\d.'
result = fullmatch(re_str, '782L')
print(result)

1.2.5 \b

检测是否是单词边界(单词的开头、单词的结尾、单词和单词之间的标点空格等)
注意：正则中遇到\b，匹配的时候先不管它，匹配成功后再回头看\b位置是否是单词边界

匹配一个字符串是前五位是whose，第五6位是空白，空白后边是where。并且第五位e的后面是个单词边界

re_str = r'\w\w\w\w\w\b\swhere'
result = fullmatch(re_str, 'whose where')
print(result)

re_str = r'abc\b'
result = fullmatch(re_str, 'abc')
print(result)

1.2.6 ^

检测字符串是否以给定的正则表达式开头

匹配一个字符串，是否以两个数字字符开头

re_str = r'^\d\d'
result = fullmatch(re_str, '23')
print(result)

result = search(r'^\d\d', '99abc11hkj')
print(result)

1.2.7 $

检测字符串是否以给定的正则表达式结束

匹配一个字符串a数字，并且a数字是字符串的结尾

re_str = r'a\d$'
result = fullmatch(re_str, 'a8')
print(result)
print('1234567890')
result = search(re_str, 'a9aaa8')
print(result)

1.2.8 \W

匹配一个非数字、字母、下划线的字符

re_str = r'\W\w'
result = fullmatch(re_str, '!a')
print(result)

1.2.9 \S

匹配非空白字符

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

1.2.10 \D

匹配一个非数字字符
1.2.11 \B 检测非单词边界

1.3.1 []

匹配中括号中出现的任意字符
注意：一个中括号只匹配一个字符

匹配一个3位的字符串，第一位是a或者b或者c,后两位是数字

re_str = r'[abc+]\d\d'
result = fullmatch(re_str, '+67')
print(result)

在正则中的中括号中的应用
(1)如果将减号放到两个字符的中间代表的是谁到谁。如果想要表示'-'符号本身，就放在开头或者结尾
- [1- 8]代表的字符集是：'1','2','3','4','5','6','7','8'
- [-18]或者[18-]: 代表的字符集是'1','8','-'

要求一个字符串中的第一个是1-8中的一个，后面两位是小写字母

re_str = r'[1-8][a-z][a-z]'
result = fullmatch(re_str, '2hn')
print(result)

re_str = r'[!+-][A-Z]'
result = fullmatch(re_str, '-D')
print(result)

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

匹配一个四位的字符串，第一位不是大写字母也不是数字，后三位是abc

re_str = r'[^A-Z\d]abc'
result = fullmatch(re_str, '#abc')
print(result)

1.3.2 * 匹配0次或者多次

匹配一个字符串，最后一位是b,b的前面有0个或者多个a

re_str = r'a*b'  # 'b', 'ab','aab', 'aaab', 'aaaab' .....
print(fullmatch(re_str, 'aaaaab'))

re_str = r'\d*'
re_str = r'[abc]*'   # '','a', 'ab', 'aa', 'abccabc' .....

1.3.3 + 匹配1次或者多次（至少一次）

判断一个字符串是否是无符号的正整数

re_str = r'[1-9]+\d*'  # 10， 11， 100 ,1000
print(fullmatch(re_str, '1010'))

1.3.4 ? 匹配0次或者一次

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

判断一个字符串是否是整数(包含正整数和负整数)

# +200, -120, 99, -1, 3, +4
re_str = r'[+-]?[1-9]+\d*'
print(fullmatch(re_str, '200'))

1.3.5
(1) {N} 匹配N次

re_str = r'\d{3}'      # 匹配3位数字字符串
re_str = r'[a-zA-Z]{3}'   # 匹配3位字母字符串
print(fullmatch(re_str, 'aHh'))

(2) {N,} 至少匹配N次

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

(3) {,N} 最多匹配N次

re_str = r'a{,4}b'  # 'b', 'ab', 'aab', 'aaab','aaaab'
print(fullmatch(re_str, 'aaaab'))

(4) {M,N} 匹配至少M次，最多N次 (N>M)

re_str = r'a{2,4}b'  # 'aab', 'aaab', 'aaaab'
print(fullmatch(re_str, 'aaab'))

3.3.分之和分组

3.3.1 | 分之(相当于逻辑运算中的or)

匹配一个字符串是三个字母或者是三个数字

re_str = r'[a-zA-Z]{3}|\d{3}'
print(fullmatch(re_str, 'abc'))

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

注意：正则中的分之有短路操作：如果使用|去连接多个条件，前面的条件已经匹配出结果，那么就不会使用后面的条件再去匹配了

3.3.2分组
a.分组

通过加()来对正则条件进行分组

两位数字两位字母出现3次

re_str = r'([a-z]{2}\d{2}){3}'
print(fullmatch(re_str, 'ac23bn45hj34'))

匹配一个字符串，按照一个数字一个字母的规律出现一次或者多次

re_str = r'(\d[a-z])+'
print(fullmatch(re_str, '9a2s3k4k9o'))

b.重复

可以通过\数字来重复匹配前面的分组中匹配的结果。数字的值代表前面的第几个分组

re_str = r'(\d{2}[A-Z])=%\1\1'
print(fullmatch(re_str,'23B=%23B23B'))

re_str = r'(\d{3})-(\w{2})\1{2}\2'
print(fullmatch(re_str,'123-aa123123aa'))

c.捕获

按照完整的正则表达式去匹配，只捕获()中的内容。只有在findall中有效

re_str = r'a(\d{3})b'
print(fullmatch(re_str, 'a786b'))
print(findall(re_str, 'a786b'))

练习：

用户名必须由字母、数字或下划线构成且长度在6_{20个字符之间,QQ号是5}12的数字且首位不能为0

user_name = input('用户名:')
qq = input('QQ:')

if fullmatch(r'\w{6,20}', user_name):
    print('用户名合法')
else:
    print('用户名不合法')

if fullmatch(r'[1-9]\d{4,11}', qq):
    print('QQ号合法')
else:
    print('QQ号不合法')

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

2.正则中的转义

2.1

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

2.2

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

注意：
a. - 只有在中括号中的两个字符之间才有特殊的意义
b. 如果特殊符号放到[]中作为字符集的内容，那么除了-在两个字符之间以外其他的都不需要转义
c. \ 不管在哪儿都需要转义, ^放在中括号的最前面需要转义

re_str = r'a\+'
print(re.fullmatch(re_str, 'a+'))   #<_sre.SRE_Match object; span=(0, 2), match='a+'>

re_str = r'\+a'
print(re.fullmatch(re_str, '+a'))   #<_sre.SRE_Match object; span=(0, 2), match='+a'>

re_str = r'\\r-a'
match1=re.fullmatch(re_str,'\\r-a')
print(re.fullmatch(re_str, '\\r-a'))  #<_sre.SRE_Match object; span=(0, 4), match='\\r-a'>
print(match1.group())     #\r-a


re_str = r'\(\d{3}'
print(re.fullmatch(re_str,'(234'))  #<_sre.SRE_Match object; span=(0, 4), match='(234'>

re_str = r'\[abc\]'

re_str = r'[\^.?*]mbc\\'
print(re.fullmatch(re_str, '.mbc\\'))  #<_sre.SRE_Match object; span=(0, 5), match='.mbc\\'>
re_str = r'[\d*]mbc\\'
print(re.fullmatch(re_str, '*mbc\\'))   #<_sre.SRE_Match object; span=(0, 5), match='*mbc\\'>

3 re模块

3.1.compile(正则表达式): 将正则表达式转换成正则表达式对象

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

3.2.match(正则表达式, 字符串) 和 fullmatch(正则表达式，字符串)

match:判断字符串的开头是否能够和正则表达式匹配
fullmatch: 判断整个字符串是否能够和正则表达式匹配

返回值都是匹配结果，如果匹配成功返回匹配对象，否则返回None

re_str = r'abc\d{3}'
match1 = re.match(re_str, 'abc234abcdef')
match2 = re.fullmatch(re_str, 'abc234')
print(match1)  #<_sre.SRE_Match object; span=(0, 6), match='abc234'>
print(match2)   #<_sre.SRE_Match object; span=(0, 6), match='abc234'>

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

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

b.group参数，用来指定分组对应的相应的结果

re_str = r'(\d{3})\+([a-z]{2})'
match1 = re.match(re_str, '234+hjaaaaaa')
print(match1)   ##<_sre.SRE_Match object; span=(0, 6), match='234+hj'>
# b. 获取匹配结果对应的字符串
print(match1.group())   #234
print(match1.group(1))   #hj
print(match1.group(2))    #234+hjaaaaaa
# c. 获取被匹配的原字符串
print(match1.string)   #234+hjaaaaaa

3.3.search(正则表达式, 字符串)

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

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

3.4.split(正则表达式,字符串)

按满足正则表达式的子串去切割字符串
返回值是列表

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

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

返回值是新的字符串

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

3.6.findall(正则表达式, 字符串)

获取字符串中所有满足正则表达式的子串
返回值是列表
注意：分组中的捕获效果在这儿有效

result = re.findall(r'([a-z]+)\d', '安徽省1boy1,and1你好福建0action1')
print(result)   #['boy', 'and', 'action']

2018-09-11 day17正则表达式