正则表达式re模块

                                                           正则表达式re模块
    compile函数运用方法 : 将正则表达式编译成一个pattern对象,这样在运用时候就不用每次输入正则表达式对象
        p = re.compile('正则表达式'，flag)
        例如:

import re
text = 'hello , Bill,would you like to play volleyball ?'
p = re.compile(r'\w*ll\w*')
print (p .findall(text)) #用带有compile函数的正则查找所有包含'll'的单词
print (re .findall(r'\w*ll\w*',text)) #用未带有compile函数的正则查找所有包含'll'的单词

#运行结果如下:
['hello', 'Bill', 'volleyball']
['hello', 'Bill', 'volleyball']

    p对象有以下方法：
    （1）match：匹配一次，默认从头开始匹配(从左往右匹配)，如果匹配不成功返回None

                    如果匹配成功，返回一个Match对象，使用group()方法获取匹配字符串
        p.match(
            string,要匹配的内容
            start,从哪里开始--默认是从0
            end，匹配到哪里。结束位置
        )
        re.match(
            正则表达式，
            string，
            flags,标识位
        )

# .表示任何一个字符，默认换行除外
ret = re.match(r'.', 'hello,laowang')
print(ret)   #<re.Match object; span=(0, 1), match='h'>
print(ret.group())  #h

# 默认不支持换行符
ret = re.match(r'.', '\nhello,laowang')
print(ret)  #None

# 让.支持换行符
ret = re.match(r'.', '\nhello,laowang', re.DOTALL)
print(ret)  #<re.Match object; span=(0, 1), match='\n'>

# \d匹配一个数字
ret = re.match(r'\d', '123abc')
print(ret)  #<re.Match object; span=(0, 1), match='1'>

# \D匹配一个非数字
ret = re.match(r'\D', 'abc123')
print(ret)  #<re.Match object; span=(0, 1), match='a'>

# \w匹配一个文字、数字、下划线
ret = re.match(r'\w', 'laowang')
print(ret)  #<re.Match object; span=(0, 1), match='l'>

ret = re.match(r'\w', '老王',re.ASCII)
print(ret)  #None

ret = re.match(r'\w', 'laowang',re.ASCII)
print(ret)  #<re.Match object; span=(0, 1), match='l'>
print('*'*100)

ret = re.match(r'\w', ',laowang')
print(ret)  #None

# []匹配范围内的一个
ret = re.match(r'[0-9]', '123abc')
print(ret)  #<re.Match object; span=(0, 1), match='1'>

ret = re.match(r'[a-z,.A-Z0-9]', '.Abc')
print(ret)  #<re.Match object; span=(0, 1), match='.'>

ret = re.match(r'[a-z]', 'Abc',re.I)
print(ret)  #<re.Match object; span=(0, 1), match='A'>


# |或者
ret = re.match(r'\d|[a-z]', '123abc')
print(ret)  #<re.Match object; span=(0, 1), match='1'>

# ()改变或者 分组
ret = re.match(r'ab(c|ba)', 'abba123')
print(ret)  #<re.Match object; span=(0, 4), match='abba'>

ret = re.match(r'[a-z]+', '0abc123')
print(ret)  #None

    （2）search：匹配一次，全文匹配，如果找到了，就返回，没有找到就返回none

                            也是用group()方法获取匹配字符串
        p.search(
            string,要匹配的内容
            start,从哪里开始--默认是从0
            end，匹配到哪里。结束位置
    
        )
        re.seach(
            正则表达式，
            string，
            flags,标识位
        )    
        

import re
text = 'hello , Bill,would you like to play volleyball ?'
p = re.compile(r'\w*ll\w*')
print (p .search(text).group())
print (re .search(r'\w*ll\w*',text).group())

结果如下:

hello
hello

    (3)findall:全文匹配，只要找到结果，就把结果放到一个list中，直到匹配到内容结尾位置。
        p.findall(
            string,要匹配的内容
            start,从哪里开始--默认是从0
            end，匹配到哪里。结束位置
        )--->list
        re.findall(
            正则表达式，
            string，
            flags,标识位
        )--->list

import re
text = 'hello , Bill,would you like to play volleyball ?'
p = re.compile(r'\w*ll\w*')
print (p .findall(text)) #用带有compile函数的正则查找所有包含'll'的单词
print (re .findall(r'\w*ll\w*',text)) #用未带有compile函数的正则查找所有包含'll'的单词

  

#运行结果如下:
['hello', 'Bill', 'volleyball']
['hello', 'Bill', 'volleyball']

 (4)finditer:  返回一个迭代器。    
        p.finditer(
            string,要匹配的内容
            start,从哪里开始--默认是从0
            end，匹配到哪里。结束位置
        )--->list
        re.finditer(
            正则表达式，
            string，
            flags,标识位
        )--->list

import re
text = 'hello , Bill,would you like to play volleyball ?'
p = re.compile(r'\w*ll\w*')
print (p .finditer(text))
print (re .finditer(r'\w*ll\w*',text))

执行结果如下

<callable_iterator object at 0x00000000021223C8>
<callable_iterator object at 0x000000000294BDD8>

    (5)sub:替换
        Pattern.sub(
                repl， #替换成什么
                String,#替换什么
                Count#替换次数
            )
        re.sub(
            正则，
            替换成什么，
            要替换什么，
            count,替换次数
            flag
        )

import re
text = 'hello , Bill,would you like to play volleyball ?'
p = re.compile(r'\w*ll\w*')
print (p .sub('A',text))
print (re .sub(r'\w*ll\w*','A',text))

执行结果如下:

A , A,would you like to play A ?
A , A,would you like to play A ?

        match对象：

            match.group()-----获取匹配的内容，也可以写成match.group(0)
            match.group(n):n>=1,此时便是取分组的内容，1，表示取第一个括号（分组）的内容，一次类推。
            match.span()--结果匹配的返回

            

    （6）split:分隔，按正则表达式能匹配到的内容进行分割字符串，返回一个list
        Pattern.split(
                    String,
                    Maxsplit#指定最大分隔次数，默认全部分隔，可选
            )
            re.split(
                正则，
                string，分割的内容
                maxsplit，分割次数，
                flag
            )

        

import re
text = 'hello , Bill,would you like to play volleyball ?'
p1=re.compile(r'\s')
print (p1 .split(text))
print (re .split(r'\s',text))

执行结果如下:

['hello', ',', 'Bill,would', 'you', 'like', 'to', 'play', 'volleyball', '?']
['hello', ',', 'Bill,would', 'you', 'like', 'to', 'play', 'volleyball', '?']

    (7)贪婪和非贪婪
        import re
        pattern = re.compile(r'ab??')
        pattern2 = re.compile(r'ab*?')

        #* --->=0
        #[0,3]---*作用于b的取值范围
        #贪婪：多——————去最大值---python默认是贪婪，就是取最大值
        #非贪婪：尽可能少————取最小值
        result = pattern.findall('abbbc')
        print(result)  #['abbb']
        

import re
pattern1 = re.compile(r'ab??')
pattern2 = re.compile(r'ab*?')
result1 = pattern1.findall('abbbc')
result2 = pattern2.findall('abbbc')
print(result1) #['a']
print(result2) #['a']

    （8）.*？,re.S
    可选修饰标志位
        re.I    使匹配对大小写不敏感
        re.L    做本地化识别（locale-aware）匹配
        re.M    多行匹配，影响 ^ 和 $
        re.S    使 . 匹配包括换行在内的所有字符(最常用)
        re.U    根据Unicode字符集解析字符。这个标志影响 \w, \W, \b, \B.
        re.X    该标志通过给予你更灵活的格式以便你将正则表达式写得更易于理解