常用内置模块（四）——subprocess、re

常用模块（四）

一、subprocess模块

1、subprocess为子流程模块，用于执行系统命令，该模块在Python全栈开发中不常用

2、常用方法

　　run 　　 返回一个表示执行结果的对象
　　call　　  返回的执行的状态码

 import subprocess

 res = subprocess.run("tasklist",shell=True,stdout=subprocess.PIPE)
 print(res.stdout.decode("gbk"))

 print(res.stderr)

 res = subprocess.call("tasklist",shell=True)
 print(res)

run方法与callt方法

3、Popen()方法

 #  第一个进程a读取tasklist的内容，将数据交给另一个进程b，进程b将数据写到文件中
 res1 = subprocess.Popen("tasklist",stdout=subprocess.PIPE,shell=True,stderr=subprocess.PIPE)

 res2 = subprocess.Popen("echo >a.txt", stdout=subprocess.PIPE, shell=True, stderr=subprocess.PIPE,stdin=res1.stdout)

 print(res2.stdout.read().decode("gbk"))

二、re模块

1、什么是re

re是正则表达式，正则表达式是一些带有特殊意义的符号或符号的组合

2、常用匹配模式

最常用的有：
　　单个字符匹配：
　　　  \w    字母数字下划线 
 　    \s     所有不可见字符（\n \t \f）
　　   \d     所有数字
　　　　.     除了\n以外的所有字符
　　　　^     字符串的开头，写在表达式的前面
　　　　$　 　 字符串的末尾，写在表达式的后面

　　范围匹配：
　　　　[abc]   括号内的一个字符     
       a|b     a或b

　　重复匹配
　　　　{}   {，m}：0到m之间，   {m,n}:m到n之前  ， {m}:必须是m
　　　  +    匹配1个或多个，会一直匹配到不满足条件为止，用“?”问号来阻止贪婪匹配(匹配最少满足条件的字符数)
       *    匹配0个或多个，会一直匹配到不满足条件为止，用“?”问号来阻止贪婪匹配(匹配最少满足条件的字符数)
       ?    匹配1个或0个

　　分组
　　　　()　　匹配括号内的表达式,提取括号中的表达式，不会改变原来的表达式逻辑意义

　　取消分组
　　　　(?: )

 import re

 src = 'abc_d12 3d d5s\nd'

 # \d 所有数字
 print(re.findall('\d', src))
 # ['1', '2', '3', '5']

 # \w 所有数字字母下划线
 print(re.findall('\w', src))
 # ['a', 'b', 'c', '_', 'd', '1', '2', '3', 'd', 'd', '5', 's', 'd']

 # \s 所有不可见字符
 print(re.findall('\s', src))
 # [' ', ' ', '\n']

 # . 所有除了\n以外的字符
 print(re.findall('.', src))
 # ['a', 'b', 'c', '_', 'd', '1', '2', ' ', '3', 'd', ' ', 'd', '5', 's', 'd']?

 # ^ 匹配行首指定字符
 print(re.findall('^a', src))
 # ['a']

 # $ 匹配行尾指定的字符
 print(re.findall('d$', src))
 # ['d']

 # [abd] 匹配中括号内的任意一个字符（a到d，1到3）
 print(re.findall('[a-d1-3]', src))
 # ['a', 'b', 'c', 'd', '1', '2', '3', 'd', 'd', 'd']
 print(re.findall('[^a-d]', src))  # 匹配除了a-d以外的字符
 # ['_', '1', '2', ' ', '3', ' ', '5', 's', '\n']

 # {m,n}
 print(re.findall('d{1,3}', 'd dd ddd dddd'))
 # ['d', 'dd', 'ddd', 'ddd', 'd']

 # +  1个或多个
 print(re.findall('d+', 'd dd ddd dddd'))
 # ['d', 'dd', 'ddd', 'dddd']

 # * 0个或多个
 print(re.findall('d*', 'd dd ddd dddd'))
 # ['d', '', 'dd', '', 'ddd', '', 'dddd', '']

 # ?  0个或1个
 print(re.findall('\d?', 'd 21dd_\n4'))
 # ['', '', '1', '2', '', '', '', '', '4', '']

常用符号

 # 贪婪匹配  *  +    不是固定的特殊符号  只是一种现象
 # 会一直匹配到不满足条件为止 用问号来阻止贪婪匹配(匹配最少满足条件的字符数)

 print(re.findall("\w+?", "ajshsjkdsd"))
 # ['a', 'j', 's', 'h', 's', 'j', 'k', 'd', 's', 'd']

 print(re.findall("\w*?", "ajshsjkdsd"))
 # ['', '', '', '', '', '', '', '', '', '', '']

 print(re.findall("\w+?s", "ajshsjkdsd"))
 # ['ajs', 'hs', 'jkds']

 print(re.findall("\w*?s", "ajshsjkdsd"))
 # ['ajs', 'hs', 'jkds']

贪婪匹配和阻止贪婪

3、re模块的常用方法

(1).findall 　　     从左往右查找所有满足条件的字符 返回一个列表
(2).search　　    返回第一个匹配的字符串，结果封装为对象
(3).match（不常用）　　 匹配行首, 返回值与search相同
(4).compile（不常用） 　 将正则表达式封装为一个正则对象，可以重复使用这个表达式

 import re

 print(re.findall('\w', src))
 # ['a', 'b', 'c', '_', 'd', '1', '2', '3', 'd', 'd', '5', 's', 'd']

 print(re.search('hello','weqwe hello dddd helllo dd'))
 # <_sre.SRE_Match object; span=(6, 11), match='hello'>

 print(re.match("hello"," world hello python"))
 # None

方法

4、分组

分组是从左边第一个左括号起，，index逐步增加，下面的1-4就是res=re.match(r"((a(b)c)(def))","abcdef")

 ts = "abcdef"
 reg = r"((a(b)c)(def))"
 regex = re.compile(reg)
 res = regex.match(ts)
 print(res)
 print(res.span()) # 匹配的结果的区间
 print(res.group(0)) # abcdef
 print(res.group(1)) # 1 -> 第一个()   abcdef
 print(res.group(2)) # abc
 print(res.group(3)) # b
 print(res.group(4)) # def
 print(res.groups()) # ('abcdef','abc','b','def')