python-re模块和subprocess模块

一、re模块

re中文为正则表达式，是字符串处理的常用工具，通常用来检索和替换符合某个模式的文本。

注：要搜索的模式和字符串都可以是unicode字符串（str）和8位字符串（bytes），但是不能将unicode字符串与字节模式匹配。

用途：1.数据验证：测试输入的字符串是否符合规定的模式

　　　2.替换文本：识别文档中的特定文本，删除或替代

　　　3.提取字符串

常用匹配模式：

贪婪模式与非贪婪模式：

贪婪模式：总是匹配尽可能多的字符

非贪婪模式：匹配尽可能少的字符

使用findall的方式演示：

# 小写w 匹配【a-zA-Z0-9_】 大写W 匹配非字母数字下划线 【^a-zA-Z0-0】
print(re.findall('w','hello eg-on 1_23')) #['h', 'e', 'l', 'l', 'o', 'e', 'g', 'o', 'n', '1', '2', '3']
print(re.findall('W','hello egon 123')) #[' ', ' ']

#小写s 匹配任意空白字符【	
f】    大写S 匹配任意非空字符
print(re.findall('s','hello eg-on 1_23')) #[' ', ' ', ' ', ' ']
print(re.findall('s','hello 
 eg-on 	 1_23')) #[' ', '
', ' ', ' ', '	', ' ']
print(re.findall('S','hello eg-on 1_23')) #['h', 'e', 'l', 'l', 'o', 'e', 'g', 'o', 'n', '1', '2', '3']

#
与	  匹配一个换行符和一个制表符
print(re.findall(r'
','hello egon 
123')) #['
']
print(re.findall(r'	','hello egon	123')) #['
']

#d匹配任意数字【0-9】   D匹配任意非数字
print(re.findall('d','hello 
 e_g-on 123')) #['1', '2', '3']
print(re.findall('D','hello 
 e_g-on 123')) #['h', 'e', 'l', 'l', 'o', ' ', 'e', 'g', 'o', 'n', ' ']

# A==>^   ==>$
print(re.findall('Ahe','hello egon 123')) #['he'],A==>^
print(re.findall('123','hello egon 123')) #['he'],==>$

#^ 开头  $结尾
print(re.findall('^h','hello egon 123')) #['h']
print(re.findall('3$','hello egon 123')) #['3']

# .匹配除
外的任意字符
print(re.findall('a.b','a1b')) #['a1b']
print(re.findall('a.b','a1b a*b a b aaab')) #['a1b', 'a*b', 'a b', 'aab']
print(re.findall('a.b','a
b')) #[]
print(re.findall('a.b','a
b',re.S)) #['a
b']
print(re.findall('a.b','a
b',re.DOTALL)) #['a
b']同上一条意思一样

#* 匹配前一个字符>=0次
print(re.findall('ab*','bbbbbbb')) #[]
print(re.findall('ab*','a')) #['a']
print(re.findall('ab*','abbbb')) #['abbbb']

#+匹配前一个字符>=1次
print(re.findall('ab+','a')) #[]
print(re.findall('ab+','abbb')) #['abbb']

#? 匹配一个字符0或者一次
print(re.findall('ab?','a')) #['a']
print(re.findall('ab?','abbb')) #['ab']

#匹配所有包含小数在内的数字
print(re.findall('d+.?d*',"asdfasdf123as1.13dfa12adsf1asdf3")) #['123', '1.13', '12', '1', '3']

#.*默认为贪婪匹配
print(re.findall('a.*b','a1b22222222b')) #['a1b22222222b']

#.*?为非贪婪匹配：推荐使用
print(re.findall('a.*?b','a1b22222222b')) #['a1b']

#{n,m}
print(re.findall('ab{2}','abbb')) #['abb']
print(re.findall('ab{2,4}','abbb')) #['abb']
print(re.findall('ab{1,}','abbb')) #'ab{1,}' ===> 'ab+'
print(re.findall('ab{0,}','abbb')) #'ab{0,}' ===> 'ab*'

#[]
print(re.findall('a[1*-]b','a1b a*b a-b'))#['a1b', 'a*b', 'a-b']
print(re.findall('a[^1*-]b','a1b a*b a-b a=b')) #[]内的^代表的意思是取反，所以结果为['a=b']
print(re.findall('a[0-9]b','a1b a*b a-b a=b'))
print(re.findall('a[a-z]b','a1b a*b a-b a=b aeb'))
print(re.findall('a[a-zA-Z]b','a1b a*b a-b a=b aeb aEb'))

#():分组
print(re.findall('ab*','abababsaa123')) #['ab', 'ab', 'ab']
print(re.findall('(ab)+123','ababab123')) #['ab']，匹配到末尾的ab123中的ab
print(re.findall('(?:ab)+123','ababab123')) #findall的结果不是匹配的全部内容，而是组内的内容,?:可以让结果为匹配的全部内容
print(re.findall('href="(.*?)"','<a href="http://www.baidu.com">点击</a>'))#['http://www.baidu.com']
print(re.findall('href="(?:.*?)"','<a href="http://www.baidu.com">点击</a>'))#['href="http://www.baidu.com"']

re常用方法：

import re
#1
print(re.findall('e','alex make love') )   #['e', 'e', 'e'],返回所有满足匹配条件的结果,放在列表里
#2
print(re.search('e','alex make love').group()) #e,只到找到第一个匹配然后返回一个包含匹配信息的对象,该对象可以通过调用group()方法得到匹配的字符串,如果字符串没有匹配，则返回None。

#3
print(re.match('e','alex make love'))    #None,同search,不过在字符串开始处进行匹配,完全可以用search+^代替match

#4
print(re.split('[ab]','abcd'))     #['', '', 'cd']，先按'a'分割得到''和'bcd',再对''和'bcd'分别按'b'分割

#5
print('===>',re.sub('a','A','alex make love')) #===> Alex mAke love，不指定n，默认替换所有
print('===>',re.sub('a','A','alex make love',1)) #===> Alex make love
print('===>',re.sub('a','A','alex make love',2)) #===> Alex mAke love
print('===>',re.sub('^(w+)(.*?s)(w+)(.*?s)(w+)(.*?)$',r'52341','alex make love')) #===> love make alex

print('===>',re.subn('a','A','alex make love')) #===> ('Alex mAke love', 2),结果带有总共替换的个数


#6
obj=re.compile('d{2}')

print(obj.search('abc123eeee').group()) #12
print(obj.findall('abc123eeee')) #['12'],重用了obj

同样的表达式，search和findall的结果不同：

print(re.search('(([+-*/]*d+.?d*)+)',"1-12*(60+(-40.35/5)-(-4*3))").group()) #(-40.35/5)
print(re.findall('(([+-*/]*d+.?d*)+)',"1-12*(60+(-40.35/5)-(-4*3))")) #['/5', '*3']

#看这个例子:(d)+相当于(d)(d)(d)(d)...,是一系列分组
print(re.search('(d)+','123').group()) #group的作用是将所有组拼接到一起显示出来
print(re.findall('(d)+','123')) #findall结果是组内的结果,且是最后一个组的结果

search与findall

补充：

在 python 的字符串中， 是被当做转义字符的。在正则表达式中， 也是被当做转义字符。这就导致了一个问题：如果你要匹配 字符串，那么传递给 re.compile() 的字符串必须是"\\"。

由于字符串的转义，所以实际传递给 re.compile() 的是"\"，然后再通过正则表达式的转义，"\" 会匹配到字符""。这样虽然可以正确匹配到字符 ，但是很麻烦，而且容易漏写反斜杠而导致 Bug。

原始字符串很好的解决了这个问题，通过在字符串前面添加一个r，表示原始字符串，不让字符串的反斜杠发生转义。那么就可以使用r"\"来匹配字符了。

二、subprocess模块

用于执行系统命令

常用方法：

　　run：返回一个表示执行结果的对象

　　call：返回的执行的状态码

总结：subprocess的好处是可以获取指令的执行结果

　　　subprocess执行指令时，可以在子进程中  这样避免造成主进程卡死

推荐阅读：https://www.cnblogs.com/yyds/p/7288916.html

补习内容：

import re
# 1）普通的字符
# res = re.match(r'a', 'abc')
# print(res.group())

# 2）单个(非换行
)任意字符 .
# res = re.match(r'.', 'abc')
# print(res.group())

# 3）字符集(单个) [...] eg: [abc] [a-z] [a-zA-Z0-9_]
# res = re.match(r'[a-zA-Z0-9_]', 'babc') #a-z或A-Z或0-9或_ == w
# print(res.group())

# 4）非w的所有字符W  拓展：d D s S
# res = re.match(r'W', '$babc')
# print(res.group())

# 5）开头、结尾(只适用于单行匹配) ^ $
ts = """abc
123
a1d
"""
res = re.match(r'^a', ts)
print(res)
# match 不与 $结合使用：匹配整个字符串的开头，只匹配一次
# search 可以与 $结合使用：匹配整个字符串(不限定从头开始)，只匹配一次
# res = re.search(r'd$', ts)
# print(res)

# res = re.match(r'^a[w]c$', "a_c")
# print(res)

# 6) 次数
# *[0, +œ) 尽可能多的匹配
# *? 尽可能少的匹配
# +[1, +œ) | ?[0, 1] | +? | ??
res = re.match(r'ab*?', "abbbbbc")
print(res)
# {m} 匹配m次 {m,n} 匹配m~n  {m,n}?
# res = re.match(r'ab{2,5}', "abbbbb")
# print(res)

# 7）或 |  a|b == [ab]
# res = re.match(r'a|b', "cbabc")
# print(res)

# 方法
# match
# search
# findall
# sub
# split
import re
# 从头开始，匹配一次(没有匹配到返回None)
# res = re.match(r'a', "abc")
# print(res)

# 匹配一次，无关位置，从前往后索引匹配(没有匹配到返回None)
res = re.search(r'a', "baca")
print(res)

# 从前往后索引匹配，匹配所有，返回列表(没有匹配到返回[])
res = re.findall(r'a', "baca")
print(res)

# 正则 替换字符串 目标字符串
# 不修改目标字符串，返回替换后的字符串
# ts = "abcdea"
# res = re.sub(r'[0-9]', "呵", "a2b12e9a")
# print(res)

# 以正则拆分成数据列表
# ts = "老男孩：python，Linux、H5、Java GO C++ AR VR"
# res = re.split(r' |：|，|、', ts)
# print(res)

# 分组()
# 1）分组不影响匹配结果 ((a(b)c)d(efg)) ==> abcdefg
# 2）0分组代表整体，第几个(就是第几位分组
import re
reg = r"((a(b)c)d(efg))"
ts = "abcdefg"
res = re.match(reg, ts)
print(res.group()) # abcdefg
print(res.group(0)) # abcdefg
print(res.group(1)) # abcdefg
print(res.group(2)) # abc
print(res.group(3)) # b
print(res.group(4)) # efg

# 
um：num为分组号 1 == book>
# reg = r"<(book>)(w+)</1"
# ts = "<book>语文</book>"
# res = re.match(reg, ts)
# print(res)

# (?P<mark>主体) (?P=mark)不占有分组
# reg = r"<(?P<tag>book>)(w+)</(?P=tag)"
# ts = "<book>语文</book>"
# res = re.match(reg, ts)
# print(res.group(2))

# (?:) 取消分组
# [('语文', '</book>'), ('数学', '</book>')]
# reg = r"(?:<book>)(w+)(</book>)"
# ts = "<book>语文</book><book>数学</book>"
# res = re.findall(reg, ts)
# print(res)