python 学习-常用模块 re，subprocess

'''
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'))