正则表达式re模块---day18

1.匹配单个字符

import re
lst = re.findall(正则表达式,要匹配的字符串)
返回的是列表，按照正则表达式匹配到的内容都扔到列表中

　　

# ### 1.预定义字符集
# \d 匹配数字
lst = re.findall("\d","sdafsdfas4657**(&^&*^%a123124")
print(lst) #['4', '6', '5', '7', '1', '2', '3', '1', '2', '4']

#\D 匹配非数字
lst = re.findall("\D","asdas4356765(*^%")
print(lst)#['a', 's', 'd', 'a', 's', '(', '*', '^', '%']

#\w 匹配字母或数字或下划线  (正则函数中,支持中文的匹配)
lst = re.findall("\w","asdf56*()*%^__89中文")
print(lst) #['a', 's', 'd', 'f', '5', '6', '_', '_', '8', '9', '中', '文']

# \W 匹配非字母或数字或下划线
lst = re.findall("\W","ssdf34&**($#56_中文")
print(lst)  #['&', '*', '*', '(', '$', '#']

# \s 匹配任意的空白符  \n \t \r " "
lst = re.findall("\s","         \n\r\t")
print(lst)#[' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '\n', '\r', '\t']

# \S 匹配任意非空白符
lst = re.findall("\S"," aa   bb \n \t \r    ")
print(lst)  #['a', 'a', 'b', 'b']

# \n 匹配一个换行符
strvar ="""
我是大哥大
"""
lst =re.findall(r"\n",strvar)
	print(lst) #['\n', '\n']

strvar ="""
他 是一个 神秘的   男孩
"""
lst = re.findall(r"\t",strvar)
print(lst) #[]

　　

# ### 2.字符组  必须匹配中括号里列举的字符[]
lst = re.findall("[abc]","sdfghjguchuatfhvb")
print(lst) #['c', 'a', 'b']  #中括号里面的字符一个一个找

print(re.findall('a[abc]b','aab abb acb adb')) #aab  abb acb

print(re.findall('a[0123456789]b','a1b a2b a3b acb ayb'))#a1b  a2b a3b
#优化：-是一个特殊的字符，代表的是一个范围0-9 0123456789
print(re.findall('a[0-9]b','a1b a2b a3b acb ayb')) #a1b a2b a3b

print(re.findall('a[a-g]b','a1b a2b a3b acb ayb adb')) #acb  adb

print(re.findall('a[ABCDEFG]b','a1b a2b a3b  aAb aDb aYb')) # aAb aDb
#优化：[A-G] 如果想要表达所有的26个大写字母[A-Z]
print(re.findall('a[A-G]b','a1b a2b a3b  aAb aDb aYb')) #aAb aDb

print(re.findall('a[0-9a-zA-Z]b','a-b aab aAb aWb aqba1b'))#aab aAb aWb aqb a1b
#注意:[0-z] 数字 小写 大写还有特殊字符 比如@.. 参照ascii表
print(re.findall('a[0-z]b','a@b aab aAb aWb aqba1b')) #a@b aab aAb aWb aqb a1b

# ^ 在字符组当中，代表除了  放到字符组的左边第一个位置
print(re.findall('a[^-+*/]b',"a%b ccaa*bda&bd")) #a%b a&b

#如果想要匹配 ^或 -，在原来的字符前面加上\，让字符的含义失效
lst =re.findall(r"e[\^\-]f","e^f e-f") #\^ \- 失去了原来转义
print(lst)  #e^f e-f

#匹配 \  再原来的基础上再加一个\
lst = re.findall(r'a\\c',"a\c")
print(lst) #['a\\c']
print(lst[0]) #a\c

res = re.findall(r'a\\b',r'a\b')
print(res) #['a\\b']
print(res[0]) #a\b
res = re.findall(r'a\\n',r'a\n')
print(res) #['a\\n']
print(res[0]) #a\n
#\b -> 转义字符 backspace

# a[\^\\]b a^b a\b
res = re.findall(r'a[\^\\]b',r'a^b a\b') #\^ \\  \让字符的含义失效
print(res) #['a^b', 'a\\b']
print(res[1]) # a\b

　　

2.多个字符的匹配

# ### 正则表达式  多个字符的匹配
import re
# 量词练习
''' ?匹配0个或者1个 '''
print(re.findall("a?b","abbzab abb aab")) #ab b ab ab b ab

''' +匹配1个或者多个'''
print(re.findall("a+b","b ab aaaaaab abb"))# ab aaaaaab ab

''' *匹配0个或者多个'''
print(re.findall("a*b","b ab aaaaaab abbbbbbb"))#b  ab aaaaaab ab b b b b b b b

''' {m,n}匹配m个至n个'''
#(1) 1<= x <= 3
print(re.findall("a{1,3}b","aaab ab aab abbb aaz aabb"))#aaab  ab aab ab aab
#(2) 前面修饰的a，必须是2个字符
print(re.findall("a{2}b","aaab ab aab abbb aaz aabb"))#aab  aab aab
#(3) 前面修饰的a，至少是2个字符，加个逗号即可
print(re.findall("a{2,}b","aaab ab aab abbb aaz aabb"))# aaab aab aab

# ### 2.贪婪模式 与 非贪婪模式
'''
贪婪模式 与 非贪婪模式：
    贪婪模式：默认向更多次匹配，底层用的是回溯算法
    非贪婪模式：默认向更少次匹配，用一个?号来进行修饰(修饰在量词的身后)
    回溯算法：从左向右进行匹配，一直到最后，直接最后再也匹配不到了，回头，寻找最后一个
    .匹配任意字符，除了换行符\n
'''
strvar = "刘能和刘老根和刘铁棍子777子888"
lst = re.findall("刘.",strvar)
print(lst) #['刘能', '刘老', '刘铁']

#贪婪模式
lst =  re.findall("刘.?",strvar) #0个或者1个，贪婪模式往更多匹配
print(lst) #['刘能', '刘老', '刘铁']

lst = re.findall("刘.+",strvar) #一个或多个 贪婪模式往更多匹配
print(lst)  #['刘能和刘老根和刘铁棍子777子888']

lst = re.findall("刘.*",strvar) #0个或者多个 贪婪模式往更多匹配
print(lst) #['刘能和刘老根和刘铁棍子777子888']

lst = re.findall("刘.{1,21}",strvar) #往最多匹配
print(lst) #['刘能和刘老根和刘铁棍子777子888']

lst = re.findall("刘.*子",strvar) # 0个或者多个 往最多匹配
print(lst) #['刘能和刘老根和刘铁棍子777子']

#非贪婪模式  量词后面有?号就表示非贪婪模式
lst= re.findall("刘.??",strvar) #0个或一个  往更少匹配
print(lst) #['刘','刘','刘']
# .表示匹配任意字符，第一个?修饰. 表示匹配0次或者一个，第二个问号表示非贪婪模式，也就是往最少的0匹配

lst = re.findall("刘.+?",strvar) #1个或多个，往更少匹配
print(lst) #['刘能', '刘老', '刘铁']

lst = re.findall("刘.*?",strvar) #0个或多个  往更少匹配
print(lst)   #['刘','刘','刘']

lst = re.findall("刘.{1,21}?",strvar) #1-21个，往更少匹配
print(lst) #['刘能', '刘老', '刘铁']

lst = re.findall("刘.*?子",strvar) #0个或多个 往更少匹配
print(lst) #["刘能和刘老根和刘铁棍子"]

lst = re.findall("刘.+?子",strvar) #1个或多个  往更少匹配
print(lst) #["刘能和刘老根和刘铁棍子"]

# ### 3.边界符 \b  ^  $
'''
\b backspace  本身就是一个转义字符
边界符 卡单词 word
    卡住左边界 \bw  以w开头
    卡住右边界  d\b  以d结尾
'''
strvar ="word pwd scf"
lst = re.findall(r".*d\b",strvar) #贪婪模式 0个或者多个 往更多匹配
print(lst)  #['word pwd']

lst = re.findall(r".*?d\b",strvar) #非贪婪模式，往更少匹配
print(lst) #["word","pwd"]

lst = re.findall(r"\bw",strvar)
print(lst) #['w']

lst = re.findall(r'\bw.',strvar)
print(lst) #['wo']

lst = re.findall(r"\bw.*?",strvar) #非贪婪模式 0个或者更多 往更少匹配
print(lst)  #['w']  

#正则表达式中写字符时，要谨慎，下面例子必须匹配到一个空格时，才结束
lst = re.findall(r"\bw.*? ",strvar)
print(lst) #['word '] #?后面加了空格 所以必须匹配到第一个空格

lst = re.findall(r"\bw\S*",strvar)
print(lst) #['word']  # \S 非空白符

lst = re.findall(r'\bw.*?d',strvar)  #非贪婪模式 0个或者更多 往更少匹配
print(lst)  #['word']

#  ^  $
'''
^  必须以..开头
$   必须以..结尾
如果出现了 ^ $,要把这个字符串看成一个整体
'''
strvar = '大哥大嫂大爷'
print(re.findall("大.",strvar))#['大哥', '大嫂', '大爷']
print(re.findall('^大.',strvar)) #['大哥']
print(re.findall('大.$',strvar)) # ['大爷']
print(re.findall('^大.$',strvar)) # []
print(re.findall('^大.*?$',strvar)) #['大哥大嫂大爷'] 只要有这种，就按最少的匹配
print(re.findall('^大.*?大$',strvar)) #[]  以大开头，还要以大结尾
print(re.findall('^大.*?爷$',strvar)) #['大哥大嫂大爷']

print(re.findall("^g.*? ",'giveme 1gfive gay')) #['giveme '] #?后面有空格
print(re.findall('five$','aassfive')) #['aassfive']
print(re.findall(('^giveme$','giveme')) #['giveme']
print(re.findall('^giveme$','giveme giveme')) #[]
print(re.findall(('giveme','giveme giveme')) #['giveme','giveme']
print(re.findall('^g.*e','giveme 1gfive gay'))##['giveme 1gfive']  以g开头尽可能多的匹配e

　　

3.匹配分组

# ### 正则表达式  匹配分组
import re
# ### 1.分组练习(用圆括号)  要所有的姓名
print(re.findall('.*?_good','wusir_good alex_good secret男_good'))
#['wusir_good', ' alex_good', ' secret男_good']

#() 显示括号里面匹配到的内容 只显示
print(re.findall('(.*?)_good','wusir_good alex_good secret男_good'))
#['wusir', ' alex', ' secret男']

# ?: 不至显示括号里面的内容  都显示
print(re.findall('(?:.*?)_good','wusir_good alex_good secret男_good'))
# ['wusir_good', ' alex_good', ' secret男_good']

# ### 2. | 代表或   a|b 匹配字符a 或 匹配字符b
#基本语法
strvar = 'abcddd'
lst =re.findall('a | b',strvar)
print(lst)  #['a', 'b']
#注意事项
# 匹配abc 或 abcd
'''
为了避免优先匹配前面的字符串，导致字符串匹配不完整
把较难匹配到的字符串写在前面，容易匹配到的字符串放到后面
'''
strvar = 'abc24234234ddabcd234234'
# lst = re.findall("abc|abcd",strvar) #注意
#print(lst)  #['abc', 'abc']  abcd没匹配到 ，所以需要改成下面这样
lst = re.findall("abcd|abc",strvar)
print(lst)  #["abc","abcd"]

# ### 3.练习
'''
 . 除了\n，能够匹配到任意字符
 \ 功效：让有意义的字符变得无意义，或者让无意义的字符变得有意义
 \. 让点原来的特殊意义失效，只是单纯的表达一个点字符
'''

#(1) 匹配小数
strvar = "5.33 3.13 34 34.  .98 9.99 sdfsdf ......"
#整数.小数
lst =re.findall("\d+\.\d+",strvar)
print(lst)  # 5.33  3.13  9.99

#(2)匹配小数和整数
#整数.小数 34 43234 .
#\d
#\d+\.\d+
lst = re.findall(r"\d+\.\d+|\d+",strvar)
print(lst)  #['5.33', '3.13', '34', '34', '98', '9.99']

#用分组形式来做
'''
findall 这个函数优先显示括号里面的内容，
如果不想显示括号内容，使用?:,显示实际匹配到的内容
'''
strvar = "5.33 3.13 34 34.  .98 9.99 sdfsdf ......"
lst = re.findall(r"\d+(?:\.\d+)?",strvar)  #\d+(?:\.\d+) 指的是出现0次或者一次，意思就是不带小数点的和带一个小数点的
print(lst) #['5.33', '3.13', '34', '34', '98', '9.99']

#匹配135或171的手机号
strvar = "asdfasd234 13591199444 17188886666 19145547744"
lst = re.findall("(?:135|137|171)\d{8}",strvar)
print(lst)

#卡主开头和结尾，数字必须是11位
strvar ='13591199444'
lst = re.findall("^(?:135|171)[0-9]{8}$",strvar)
print(lst)

# ### search 函数
'''
findall  把所有匹配到的字符串都搜出来，返回列表
          不能把分组内容和匹配的内容同时显示出来

search    只要搜索到一个结果就返回，返回对象
            可以把分组内容和匹配的内容同时显示出来

group : 对象.group()  直接获取匹配到的内容
groups：对象.groups() 直接获取分组里面的内容
'''
# 匹配www.baidu.com  或者 www.oldboy.com
strvar = 'www.baidu.com'
lst = re.findall("(?:www)\.(?:baidu|oldboy)\.(?:com)",strvar)
print(lst) #['www.baidu.com']

obj = re.search("(www)\.(baidu|oldboy)\.(com)",strvar)
print(obj) #<_sre.SRE_Match object; span=(0, 13), match='www.baidu.com'>
#获取的是匹配到的数据
print(obj.group()) # www.baidu.com
#获取的是分组里面的数据
print(obj.groups()) #('www', 'baidu', 'com')

　　

4.命名分组

# ### 正则表达式 命名分组
import re
strvar = "<div>明天就放假了,很开心</div>"

#当不清楚字符串中含有什么内容时，可以用.*?进行取代
lst = re.findall(r"<(.*?)>(.*?)<(.*?)>",strvar)
print(lst) #[('div', '明天就放假了,很开心', '/div')]

#(1) 反向引用
# \1 代表反向引用，将第一个括号匹配的字符串，在\1位置处在引用一次
lst = re.findall(r"<(.*?)>(.*?)</\1>",strvar)
#省略了再写.*? 直接用\1引用第一个括号里面的内容，引用的是跟括号1里面一样的内容，
#\1位置还需要别的内容需自己再添加，如要匹配的是/div，所有还需要自己再加一个/
print(lst) ##[('div', '明天就放假了,很开心', '/div')]

# \1 代表第一个括号， \2代表第二个括号
strvar = "a1b2cab"
obj = re.search(r"(.*?)\d(.*?)\d(.*?)\1\2",strvar)
print(obj)
#返回匹配到的字符串
res = obj.group()
print(res) ##"a1b2cab"
#返回匹配到的分组内容
res = obj.groups()
print(res) ##('a', 'b', 'c')

#(2) 命名分组
'''
#2.命名分组(给小组起名)
3)(?p<组名>正则表达式) 给这个组起一个名字 大写的P
4)(?p=组名) 引用之前组的名字，把该组名匹配到的内容放到当前位置
'''
#方法一
strvar = "a1b2cab"
obj = re.serach(r"(?P<tag1>.*?)\d(?P<tag2>.*?)\d(?P<tag3>.*?)\1\2",strvar)
print(obj.group()) #a1b2cab

#方法二
strvar = "a1b2cab"
obj = re.search(r"(?P<tag1>.*?)\d(?P<tag2>.*?)\d(?P<tag3>.*?)(?P=tag1)(?P=tag2)",strvar)
print(obj.group()) #a1b2cab
#总结：目前可以用\1\2以及命名分组(?P=tag1)形式引用前面匹配到的内容