'''
re 模块
正则:正则就是用一些具有特殊含义的符号组合到一起(称为正则表达式)来描述字符或者字符串的方法。
正则表达式:是一个特殊的字符序列,它能帮助你方便的检查一个字符串是否与某种模式匹配。
'''
# import re
'''正则表达式:'''
# src = 'hello_world,\t6666\n'
# # \w:匹配非字母数字以及下划线
# # \W:匹配非字母数字下划线
# print(re.findall('\w',src))
# print(re.findall('\W',src))
# #\s:匹配任意空白字符,等价于[\t\n\r\f]
# #\S:匹配任意非空字符
# print(re.findall('\s',src))
# print(re.findall('\S',src))
# \n \t都是空,都可以被\s匹配
# print(re.findall('\s','hello \n\t 123'))
# \n:匹配一个换行符
# \t:匹配一个制表符
# print(re.findall(r'\n','hello\n123'))
# print(re.findall(r'\t','hello\t123'))
# \d:匹配所有数字,等价于[0-9]
# \D:匹配任意非数字
# print(re.findall('\d','hello 123')) #['1', '2', '3']
# print(re.findall('\D','hello 123'))#['h', 'e', 'l', 'l', 'o', ' ']
# \A:匹配字符串开始
# \Z:匹配字符串结束,如果是存在换行符,只匹配到换行前的结束字符串
# print(re.findall('\Ahe','hello123')) #['he'],\A==>^
# print(re.findall('123\Z','hello123')) #['he'],\Z==>$
# ^:匹配字符串的开头
# $:匹配字符串的末尾
# print(re.findall('^h','hello 123')) #['h']
# print(re.findall('3$','hello 123')) #['3']
#
# 重复匹配:| . | * | ? | .* | .*? | + | {n,m} |
# .:匹配除了\n的任意字符。当re.DOTALL标记被指定时,可以匹配包括\n的任意字符
# 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\nb')) #[]
# print(re.findall('a.b','a\nb',re.S)) #['a\nb']
# print(re.findall('a.b','a\nb',re.DOTALL)) #['a\nb']同上一条意思一样
# *:表示0个或多个的表达式
# print(re.findall('b*','bbbbbbb')) #['bbbbbbb', '']
# print(re.findall('ab*','bbbbbbb')) #[]
# print(re.findall('ab*','a')) #['a']
# print(re.findall('ab*','abbbb')) #['abbbb']
# print(re.findall('ab*','aaaaaabbbb')) #['a', 'a', 'a', 'a', 'a', 'abbbb']
# print(re.findall('ab*','aa11111aaabbbb')) #['a', 'a', 'a', 'a', 'abbbb']
# +:匹配1个或多个的表达式
# print(re.findall('ab+','a')) #[]
# print(re.findall('ab+','abbb')) #['abbb']
# ?:匹配重复0次或1次,非贪婪方式
# 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']
# #{n,m}:匹配到出现 n-m 次的片段,贪婪方式
# print(re.findall('ab{2}','abbb')) #['abb']
# print(re.findall('ab{2,4}','abbb')) #['abbb']
# print(re.findall('ab{1,}','abbb')) #['abbb'] 'ab{1,}' ===> 'ab+'
# print(re.findall('ab{0,}','abbb')) #['abbb'] 'ab{0,}' ===> 'ab*'
# []:字符集合,[amk] 匹配a,m,或 k
# []内的都为普通字符了,且如果-没有被转意的话,应该放到[]的开头或结尾
# 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']
# [0-9]匹配包含0-9的数字
# print(re.findall('a[0-9]b','a1b a*b a-b a=b'))#['a1b']
# # [a-z]匹配包含a-z的字母
# print(re.findall('a[a-z]b','a1b a*b a-b a=b aeb'))#['aeb']
# # [A-Z]匹配包含A-Z的字母
# print(re.findall('a[a-zA-Z]b','a1b a*b a-b a=b aeb aEb'))#['aeb', 'aEb']
# 注意:re模块使用的是系统内的C模块,所以传输需要先经过python编译之后再放入c模块
# 对于正则来说a\\c确实可以匹配到a\c,但是在python解释器读取a\\c时,会发生转义,然后交给re去执行,所以抛出异常
# print(re.findall('a\\c','a\c'))
# r代表告诉解释器使用rawstring,即原生字符串,把我们正则内的所有符号都当普通字符处理,不要转义
# print(re.findall(r'a\\c','a\c'))
# #同上面的意思一样,和上面的结果一样都是['a\\c']
# print(re.findall('a\\\\c','a\c'))
#
#
# #():分组(group),不改变整体匹配方式,但优先输出分组内部值
# print(re.findall('ab+','ababab123'))#['ab', 'ab', 'ab']
# print(re.findall('(ab)+123','ababab123'))#['ab'],匹配到末尾的ab123中的ab
# #findall的结果不是匹配的全部内容,而是组内的内容,?:可以让结果为匹配的全部内容
# print(re.findall('(?:ab)+123','ababab123'))
# 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"']
#
# #|:a|b 匹配a或b
# print(re.findall('compan(?:y|ies)',
# 'Too many companies have gone bankrupt, and the next one is my company'))
'''
正则表达式的贪婪与非贪婪匹配:
贪婪匹配:
正则表达式一般趋向于最大长度匹配,也就是所谓的贪婪匹配。.+*默认为贪婪匹配
非贪婪匹配:
就是匹配到结果就好,就少的匹配字符。.*+?用来阻止贪婪,取最少值返回
'''
# .*默认为贪婪匹配
# print(re.findall('a.*b','a1b22222222b')) #['a1b22222222b']
# .*?为非贪婪匹配:推荐使用
# print(re.findall('a.*?b','a1b22222222b')) #['a1b']
'''
re模块
findall: findall(pattern,string),查找所有满足条件的字符
search: search(pattern,string[,flags]),在字符串中查找,返回第一个匹配的字符串
分装返回对象为,span = (0,5) (匹配的位置)左闭右开
matc : match(pattern,string[,flags]) 在字符串开头查找,与search返回值相同
split:split(pattern,string[,maxsplit=0])根据模式切割字符串
compile:compile(pattern,[,flags]) 根据包含正则表达式的字符串创建模式对象
sub : sub(pat,repl,string[,count=0]) 将字符串中模式pat匹配的子串都替换为repl
注意:sub方法可以将一个函数作为第二个参数传入,并且最后函数的返回值作为替换字符串
例如:
def func(match):
res = match.group()
res = str(int(res)+1)
return res
res = re.sub(r'\d+',fn,'我:6666,你:233')
print(res)
#我:6667,你234
subn : subn(pattern, repl, string, count=0, flags=0)
将字符串中模式pat匹配的子串都替换为repl,返回 元组('已变字符串',替换次数)
匹配对象方法:
group(num=0) : 匹配的整个表达式的字符串
group() 可以一次输入多个组号,在这种情况下它将返回一个包含那些组所对应值的元组。
groups(): 返回一个包含所有小组字符串的元组,从 1 到 所含的小组号。
参数:
pattern 匹配的正则表达式
string 要匹配的字符串。
flags 标志位,用于控制正则表达式的匹配方式,如:是否区分大小写,多行匹配等等。
epl : 替换的字符串,也可为一个函数
count : 模式匹配后替换的最大次数,默认 0 表示替换所有的匹配。
注:re.match与re.search的区别:
re.match只匹配字符串的开始,如果字符串开始不符合正则表达式,则匹配失败,函数返回None
re.search匹配整个字符串,直到找到一个匹配。
'''
import re
# ['e', 'e', 'e'],返回所有满足匹配条件的结果,放在列表里
# print(re.findall('e','alex make love'))
# e,只到找到第一个匹配然后返回一个包含匹配信息的对象,
# 该对象可以通过调用group()方法得到匹配的字符串,如果字符串没有匹配,则返回None。
# print(re.search('ee', 'alxe make loveee'))
# print(re.search('e', 'alex make love').group())
# None,同search,不过在字符串开始处进行匹配,完全可以用search+^代替match
# print(re.match('e', 'alex make love'))
# ['', '', 'cd'],先按'a'分割得到''和'bcd',再对''和'bcd'分别按'b'分割
# print(re.split('[ab]', 'abcd'))
# 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'\5\2\3\4\1', 'alex make love'))
# ===> love make alex
# print('===>', re.subn('a', 'A', 'alex make love')) # ===> ('Alex mAke love', 2),结果带有总共替换的个数
# obj = re.compile('\d{2}')
# print(obj.search('abc123eeee').group()) # 12
# print(obj.findall('abc123eeee')) # ['12'],重用了obj
'''
subprocess模块
提供了一种一致的方法来创建和处理附加进程,与标准库中的其它模块相比,提供了一个更高级的接口。
常用方法:
run: 返回一个表示执行结果的对象
call: 返回执行的状态码
总结:
subprocess的好处是可以获取指令的执行结果,且执行指令时可以在子进程中,避免造成主进程卡死
'''
import subprocess
# run 执行指令并返回,PIPE:通道
# res = subprocess.run('tasklist',shell=True,stdout=subprocess.PIPE)
# print(res)
# print(res.stderr)
# print(res.stdout.decode('gbk'))
# call 父进程等待子进程执行命令,返回子进程执行命令的状态码,如果出现错误,不进行报错
# res = subprocess.call('tasklist',shell=True)
# print(res)
# 注意:
# shell默认为False,在Linux下,shell=False时, Popen调用os.execvp()执行args指定的程序;
# shell=True时,如果args是字符串,Popen直接调用系统的Shell来执行args指定的程序,
# 如果args是一个序列,则args的第一项是定义程序命令字符串,其它项是调用系统Shell时的附加参数。
#
# 在Windows下,不论shell的值如何,Popen调用CreateProcess()执行args指定的外部程序。
# 如果args是一个序列,则先用list2cmdline()转化为字符串。
# 但需要注意的是,并不是MS Windows下所有的程序都可以用list2cmdline来转化为命令行字符串。
# 在windows下,调用脚本时要写上shell=True。
# Popen :subprocess模块中只定义了一个类: Popen
# Popen对象创建后,主程序不会自动等待子进程完成。
# 我们必须调用对象的wait()方法,父进程才会等待 (也就是阻塞block)
# stdout=subprocess.PIPE,stderr=subprocess.PIPE 使用管道将stdout和stderr的输出为打印输出
# res1 = subprocess.Popen('tasklist', stdout=subprocess.PIPE, shell=True, stderr=subprocess.PIPE)
# print(res1)
# print(res1.stdout.read().decode('gbk'))
# print(res1.stderr.read().decode('gbk'))#错误信息返回
# 将上述的输出结果作为输入给res2进行处理
# res2 = subprocess.Popen('findstr',stdout=subprocess.PIPE,shell=True,stderr=subprocess.PIPE,stdin=res1)
# print(res2)
# print(res2.stdout.read().decode('gbk'))
# print(res2.stderr.read().decode('gbk'))
python 学习-常用模块 re,subprocess
猜你喜欢
转载自blog.csdn.net/qq_33961117/article/details/81666493
今日推荐
周排行