2018-09-11 day17正则表达式总结

一.正则表达式

正则表达式就是用来检测字符串是否满足某种规则的工具
例如：1.账号是手机号/邮箱/多少位由什么东西组成等....
2.脏话替换成*等...

1.正则语法

2.python对正则表达式的支持，提供了一个内置模块:re
fullmatch（正则表达式，字符串）：判断整个字符串是否符合正则表达式规则
a.单个字符
1)匹配任意字符
匹配一个字符串，只有一个字符并且这个字符是任意字符

from re import fullmatch, search, findall
re_str = r'.'
result = fullmatch(re_str, 'a')
print(result)
输出：
<_sre.SRE_Match object; span=(0, 1), match='a'>

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

re_str = r'.'
result = fullmatch(re_str, 'an')
print(result)
输出：
<_sre.SRE_Match object; span=(0, 2), match='an'>

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

re_str = r'abc.'
result = fullmatch(re_str, 'abc%')
print(result)
输出:
<_sre.SRE_Match object; span=(0, 4), match='abc%'>

4)\w匹配字母数字下划线
匹配一个字符串，前三位分别是abc最后两个是字母数字下划线

re_str = r"abc\w\w"
result = fullmatch(re_str,"abc2g")
print(result)
输出：
<_sre.SRE_Match object; span=(0, 5), match='abc2g'>

5)\s 匹配空白字符（空白指的是空格，制表符和回车等所有能产生空白的字符）

re_str = r'\w\w\w\s.'
result = fullmatch(re_str, 'hu2\t?')
print(result)
输出:
<_sre.SRE_Match object; span=(0, 5), match='hu2\t?'>

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

re_str = r"\d\d\d."
result = fullmatch(re_str,"121#")
print(result)
输出：
<_sre.SRE_Match object; span=(0, 4), match='121#'>

\b 检测是否是单词边界(单词的开头、单词的结尾、单词和单词之间的标点空格等)
注意：正则中遇到\b，匹配的时候先不管它，匹配成功后再回头看\b位置是否是单词边界
匹配一个字符串是前四位是when，第五位是空白，空白后边是where。并且第四位n的后面是个单词边界

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

re_str = r'abc\b'
result = fullmatch(re_str, 'abc')
print(result)
输出:
<_sre.SRE_Match object; span=(0, 10), match='when where'>
<_sre.SRE_Match object; span=(0, 3), match='abc'>

8. ^ 检测字符串是否以给定的正则表达式开头
   匹配一个字符串，是否以两个数字字符开头

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

result = search(r'^\d\d', '99abc11hkj')
print(result)
输出:
<_sre.SRE_Match object; span=(0, 2), match='23'>
<_sre.SRE_Match object; span=(0, 2), match='99'>

9)$ 检测字符串是否以给定的正则表达式结束
匹配一个字符串a数字，并且a数字是字符串的结尾

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

result = search(re_str, 'a9aaa8')
print(result)
输出:
<_sre.SRE_Match object; span=(0, 2), match='a8'>
<_sre.SRE_Match object; span=(4, 6), match='a8'>

10. \W 匹配一个非数字、字母、下划线的字符

re_str = r'\W\w'
result = fullmatch(re_str, '!a')
print(result)
输出:
<_sre.SRE_Match object; span=(0, 2), match='!a'>

11. \S 匹配非空白字符

re_str = r"\S\w\w\w"
result = fullmatch(re_str,"@a3f")
print(result)
输出：
<_sre.SRE_Match object; span=(0, 4), match='@a3f'>

12. \D 匹配一个非数字字符
13. \B 检测非单词边界

b.匹配次数
1.[] 匹配中括号中出现的任意字符
注意：一个中括号只匹配一个字符
匹配一个3位的字符串，第一位是a/b/c后两位是数字

re_str = r"[abc]\d\d"
result = fullmatch(re_str,"c67")
print(result)
输出:
<_sre.SRE_Match object; span=(0, 3), match='c67'>

2." -" 在正则中的中括号中的应用：如果将减号放到两个字符的中间代表的是谁到谁。如果想要表示'-'符号本身，就放在开头或者结尾
[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)
输出:
<_sre.SRE_Match object; span=(0, 3), match='2hn'>
<_sre.SRE_Match object; span=(0, 2), match='-D'>

3. [^字符集] 匹配不在[]字符集中的任意一个字符
   匹配一个四位的字符串，第一位不是大写字母也不是数字，后三位是abc

re_str = r'[^A-Z\d]abc'
result = fullmatch(re_str, '#abc')
print(result)
输出:
<_sre.SRE_Match object; span=(0, 4), match='#abc'>

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

re_str = r"a*b"
print(fullmatch(re_str,"aaab"))
输出:
<_sre.SRE_Match object; span=(0, 4), match='aaab'>

5)+ 匹配一次或者多次（至少一次）
判断一个字符串是否是无符号的正整数

re_str = r"[1-9]+\d*"
print(fullmatch(re_str,'10'))
输出：
<_sre.SRE_Match object; span=(0, 2), match='10'>

6)？匹配零次或一次

re_str = r"@?\d+"
print(fullmatch(re_str,"@124455"))
输出:
<_sre.SRE_Match object; span=(0, 7), match='@124455'>

7)判断一个字符串是否是整数(包含正整数和负整数)
+200, -120, 99, -1, 3, +4

re_str = r'[+-]?[1-9]+\d*'
print(fullmatch(re_str, '200'))
输出:
<_sre.SRE_Match object; span=(0, 3), match='200'>

8. {N} 匹配N次

re_str = r"\d{3}"
re_str = r"[a-zA-Z]{3}"
print(fullmatch(re_str,'aHh'))
  输出:
<_sre.SRE_Match object; span=(0, 3), match='aHh'>

9. {N,} 至少匹配N次

re_str = r"\w{4,}"
print(fullmatch(re_str,"hanc_123"))
输出:
<_sre.SRE_Match object; span=(0, 8), match='hanc_123'>

{,N}最对匹配N次

re_str = r'a{,4}b'  
print(fullmatch(re_str, 'aaaab'))
输出:
<_sre.SRE_Match object; span=(0, 5), match='aaaab'>

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

re_str = r'a{2,4}b'  # 'aab', 'aaab', 'aaaab'
print(fullmatch(re_str, 'aaab'))
输出:
<_sre.SRE_Match object; span=(0, 4), match='aaab'>

c.分支和组合

1. | 分之(相当于逻辑运算中的or)
   匹配一个字符串是三个字母或者是三个数字

re_str = r'[a-zA-Z]{3}|\d{3}'
print(fullmatch(re_str, 'abc'))
输出:
<_sre.SRE_Match object; span=(0, 3), match='abc'>

2. '\d{3}[a-z]{2}'是分之中的第一个条件， '[A-F]{3}'是分之的第二个条件

re_str = r'\d{3}[a-z]{2}|[A-F]{3}'
print(fullmatch(re_str, 'ABC'))
输出:
<_sre.SRE_Match object; span=(0, 3), match='ABC'>

3)分组 通过加()来对正则条件进行分组
两位数字两位字母出现3次

re_str = r"([a-z]{2}\d\d){3}"
print(fullmatch(re_str,"sa23er45gh67"))
输出:
<_sre.SRE_Match object; span=(0, 12), match='sa23er45gh67'>

练习写一个正则表达式，能够匹配出字符串中所有的数字（包括整数和小数）
"acx12.5fgd60,30kkk9sf0.12"

re_str = r"\d+[.]\d+|[1-9]\d*"
print(findall(re_str,"acx12.5fgd60,30kkk9sf0.12"))
输出:
['12.5', '60', '30', '9', '0.12']

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

re_str = r"(\d[a-z])+"
print(fullmatch(re_str,"7a7f0h7d0g8h6k"))
输出:
<_sre.SRE_Match object; span=(0, 14), match='7a7f0h7d0g8h6k'>

5）重复
可以通过\数字来重复匹配前面的括号中匹配的结果

re_str = r"(\d{2}[A-Z])=%\1\1"
print(fullmatch(re_str,"28M=%28M28M"))
re_str = r"(\d{3})-(\w{2})\1\2"
print(fullmatch(re_str,"123-aa123aa"))
输出:
<_sre.SRE_Match object; span=(0, 11), match='28M=%28M28M'>
<_sre.SRE_Match object; span=(0, 11), match='123-aa123aa'>

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

re_str = r"a(\d{3})b"
print(fullmatch(re_str,"a245b"))
print(findall(re_str,"a345b"))
输出:
<_sre.SRE_Match object; span=(0, 5), match='a245b'>
['345']

正则中的分支有短路操作：如果使用|去连接多个条件，前面的条件已经匹配出结果，那么后面的条件就不会去匹配了
练习：
用户名必须由字母，数字，或下划线构成且长度在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不可用")
输出:
用户名：qwert12
QQ:8888888
用户名合法
qq可用

二.正则中的转义

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

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"\\w-a"
print(re.fullmatch(re_str,"\w-a"))
输出:
<_sre.SRE_Match object; span=(0, 4), match='\\w-a'>
re_str = r"\(\d{3}"
print(re.fullmatch(re_str,"(234"))
输出:
<_sre.SRE_Match object; span=(0, 4), match='(234'>
re_str = r'[\^.?*]mbc\\'
print(re.fullmatch(re_str, '?mbc\\')
输出:
<_sre.SRE_Match object; span=(0, 5), match='?mbc\\'>

三.re模块

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

import re
re_str = r"\d+"
re_object = re.compile(re_str)
print(re_object)

#不转成对象，调用相应的函数
re.fullmatch(re_str,"78sd")
#转换成对象，调用相应的方法
re_object.fullmatch("78sd")

2.match(正则表达式，字符串) 和fullmatch
match:判断字符串的开头是否能够和正则表达式匹配
fullmatch:判断整个字符串是否能够和正则表达式匹配
返回值都是匹配结果，如果匹配成功返回匹配对象，否则返回None

re_str = r"abc\d{3}"
match1= re.match(re_str,"abc234asffss")
match2 = re.fullmatch(re_str,"abc234")
print(match1)
print(match2)
输出:
<_sre.SRE_Match object; span=(0, 6), match='abc234'>
<_sre.SRE_Match object; span=(0, 6), match='abc234'>
#匹配到的范围，匹配结果字符的下标范围:(起始下标,结束下标)-----结束下标取不到

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

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

re_str = r"(\d{3})\+([a-z]{3})"
match1 = re.match(re_str,"456+asd")
print(match1)
print(match1.span())
输出：
<_sre.SRE_Match object; span=(0, 7), match='456+asd'>
(0, 7)
# 在匹配结果中，获取第1个分组的范围
print(match1.span(1))    # （0,3）
# 在匹配结果中，获取第2个分组的范围
print(match1.span(2))  # （4,7）

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


#b.获取匹配结果对应的字符串
print(match1.group())   #456+asd
print(match1.group(1))  #456
print(match1.group(2))   #asd

#c.获取被匹配的原字符串
print(match1.string)   #456+asd

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

search1 = re.search(r"\d+aa","hel8aafglo 32aabcd world")
print(search1)
if search1:
    print(search1.span())
输出:
<_sre.SRE_Match object; span=(3, 6), match='8aa'>
(3, 6)

练习：使用search将一个字符串中所有的数字字符串全部找到
"工资是10000元，年龄是18岁，身高是：180，颜值100分"
str1 = "工资是10000元，年龄是18岁，身高是：180，颜值100分"

re_str = r"[1-9]\d*"
search2 = re.search(re_str,str1)
while search2:
    print(search2.group())
    end = search2.end()
    str1 = str1[end:]
    search2 = re.search(re_str,str1)
输出：
10000
18
180
100

5.split(正则表达式，字符串)
按满足正则表达式的子串去切割字符串
中文属于\w 范围

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

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

word = "你丫傻叉么，fuck you"
result = re.sub(r"傻叉|fuck","*",word)
print(result)
输出：
你丫*么，* you

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

result = re.findall(r"\d([a-z]+)","沪江1beautiful,summertime,3action")
print(result)
输出:
['beautiful', 'action']