re正则表达式模块

每个+号可展开，每个加号展开后中去掉''' '''注释后可运行

#正则的组成：
#原子，元字符，模式修正符【其他语言中可能存在定界符】

#基础知识
'''
#原子
# 组成正则表达式的最小单位，一个正则表达式至少需要一个原子
# 1所有可见字符都是原子：a，b，c，d...A,B,C,D...你，我，他...+-*/##@
# 2所有不可见字符也是原子：\t    \n  \r ...
# 3正则专用转义字符：
# \d   表示0~9之间任意【一个】字符   ->[0123456789]自定义原子列表格式
# \D   表示除了0~9之外的任意【一个】字符  ->[^0123456789]自定义排除列表
# \s	 表示任意【一个】空白字符（不可见）        \t \n都算   -> [\n\r\t\v\f]自定义原子列表格式
# \S	 表示任意【一个】非空白字符（可见字符）    ->[^ \n\r\t\v\f]自定义排除列表
# \w   表示0~9 a~z A~Z和_中的任意【一个】字符     ->[a-zA-Z0-9_]自定义原子列表格式
# \W	 表示除了0~9 a~z A~Z之外的任意【一个】字符   ->[^a-zA-Z0-9_]自定义排除列表
# .	 表示任意一个字符【除了\n】

#正则表达式本质是字符串，单独使用没有意义，正则表达式需要配合相关的函数和方法

#re模块：正则表达式专用模块，提供正则相关的操作方法
'''

#search方法
'''
import re
#search：查找符号正则表达式的第一个内容

#准备正则表达式
pattern = r'baidu'#python 中要使用r模式的字符串表示

#正则查找的字符串
url = 'http://www/baidu.com'

#匹配操作
result = re.search(pattern,url)
#search(pattern: Pattern[AnyStr]【字符串】,string: AnyStr【要查找的字符串】,flags: Union[int, RegexFlag] = ...) -> Optional[Match[AnyStr]]
print(result)
#<_sre.SRE_Match object; span=(11, 16), match='baidu'>
'''

#原子测试
'''    
#准备正则表达式
pattern = r'\d'

#正则查找的字符串
url = 'http://www/bai1du.c9om'

#匹配操作
result = re.search(pattern,url)
#search(pattern: Pattern[AnyStr]【字符串】,string: AnyStr【要查找的字符串】,flags: Union[int, RegexFlag] = ...) -> Optional[Match[AnyStr]]
print(result)
#<_sre.SRE_Match object; span=(14, 15), match='1'>   只能匹配到第一个内容
'''

# 元字符（一）：【原子修饰符】
'''
    #需要0-9奇数组成的原子1,3,5,7,9

    #1  []自定义原子列表
        #表示自定义原子列表中的任意一个字符,如果多个字符在asscii码中连续，可以进行缩写，例如[0123456789] 可改写成-> [0-9]
    #2  [^]自定义排除列表
        #表示原子列表之外的任意一个字符,如果多个字符在asscii码中连续，可以进行缩写，例如[0123456789] 可改写成-> [0-9]
    #3  与数量相关的元字符
        #以下只修饰前面的一个原子
        # +  表示一个以上的修饰原子 [1~正无穷]  ->   {1,}
        # ？ 表示0个或1个修饰的原子 [0或者1]   ->   {0,1}
        # *  表示任意个修饰的原子  [0~正无穷]  ->   {0,}
        # {m}   表示必须是m个修饰原子
        # {m,n} 表示修饰的原子数量是m到n之间的数量（包含m也包含n）
        # {m,}  表示修饰的原子是m个到正无穷（包含m）
        # {,n}  表示0-n个修饰的原子（包含0页包含n）

import re
#准备正则表达式
pattern1 = r'[13579]'#1或者3或者5或者7或者9
pattern2 = r'[^0123456789]'
pattern3 = r'go?gle'#问号？修饰o
pattern4 = r'go+gle'
pattern5 = r'go*gle'
pattern6 = r'go{3,}gle'

#正则查找的字符串
url1 = 'dfbv2dv1fdfv4'
url2 = 'asd123'
url3 = 'www.gogle.com'
url4 = 'www.goooooooogle.com'
url5 = 'www.ggle.com'
url6 = 'www.goooooooogle.com'
#匹配操作
result1 = re.search(pattern1,url1)
print(result1)
    #<_sre.SRE_Match object; span=(7, 8), match='1'>
result2 = re.search(pattern2,url2)
print(result2)
    #<_sre.SRE_Match object; span=(0, 1), match='a'>
result3 = re.search(pattern3,url3)
print(result3)
    #<_sre.SRE_Match object; span=(0, 1), match='a'>
result4 = re.search(pattern4,url4)
print(result4)
    #<_sre.SRE_Match object; span=(4, 16), match='goooooooogle'>
result5 = re.search(pattern5,url5)
print(result5)
    #<_sre.SRE_Match object; span=(4, 8), match='ggle'>
result6 = re.search(pattern6,url6)
print(result6)
'''

# 元字符（二）
'''
    #1 \A  表示限定内容必须在整个字符串的开头部位
    #2 \Z  表示限定内容必须在整个字符串的结束部位
    #3 ^   相当于\A，并且支持多行匹配模式，记得在后面加上：'re.M'-模式修正符号
    #4 $   相当于\Z，并且支持多行匹配模式
    #额外补充：多行模式：如果字符串中包含\n,则可以在匹配时使用多行匹配模式，多行匹配模式
        # 就是将每一行当做独立的字符串进行匹配。
        # 注意：多行模式需要使用模式修正符

    #5 \b   表示能够当做英文单词分割的字符，（除了字母和数字，都是词边界 汉子作为字母处理）
    #6 \B   表示不能够当做英文单词分割的字符，（非词边界，就是字母和数字）代表一个字符
    #7 |    表示选择关系，左右的内容二选一   非常重要，是运算规则
    #8 ()   1.改变正则表达式中的优先级关系
    #       2.将多个原子视为一个原子处理，方便使用元字符，【可以叫做组 或者模式单元】
    #       3.将匹配的内容当做模式单元进行存储
 
import re

#准备正表达式
pattern1 = r'\Ahttp'
pattern2 = r'm\Z'
pattern3 = r'^http'
pattern4 = r'\bmy'  #\b的作用是my前必须是可以作为分隔符号的东西
pattern5 = r'\bmy\b'   #my必须是个单词才能被匹配
pattern6 = r'\bmy'
pattern7 = r'\bmy\B' #my的左边是词边界，my的右边不能是词边界
pattern8 = r'ab|cd' #ab或者cd
pattern9 = r'a(b|c)d'  #acd或者abd
pattern10 = r'(go)+gle'


#正则查找的字符串
url1 = 'http://www.google.com'
url2 = 'http://www.google.coma'
url3 = '谷歌的地址是\nhttp://www.google.coma'
url4 = 'if you lose myself'  #如果是if you lose123myself，则输出none
url5 = 'if you lose my self'
url6 = 'if you lose myself，if you feel my love'
url7 = 'if you lose myself，if you feel my love'
url8 = '我喜欢的字母是abcd'
url9 = '我喜欢的字母是acd'
url10 = 'http://www.gogogogle.com'


#匹配操作
result1 = re.search(pattern1,url1)
print(result1)
    #<_sre.SRE_Match object; span=(0, 4), match='http'>
result2 = re.search(pattern2,url2)
print(result2)
    #None
result3 = re.search(pattern3,url3,re.M)#'re.M'-模式修正符号
print(result3)
    #<_sre.SRE_Match object; span=(7, 11), match='http'>
result4 = re.search(pattern4,url4)
print(result4)
    #<_sre.SRE_Match object; span=(12, 14), match='my'>
result5 = re.search(pattern5,url5)
print(result5)
    #<_sre.SRE_Match object; span=(12, 14), match='my'>
result6 = re.findall(pattern6,url6)                 #findall是多次匹配
print(result6)
    #['my', 'my']
result7 = re.findall(pattern7,url7) #findall是多次匹配
print(result7)
    #['my']
result8 = re.search(pattern8,url8) #findall是多次匹配
print(result8)
    #<_sre.SRE_Match object; span=(7, 9), match='ab'>
result9 = re.search(pattern9,url9) #findall是多次匹配
print(result9)
    #<_sre.SRE_Match object; span=(7, 10), match='acd'>
result10 = re.search(pattern10,url10) #findall是多次匹配
print(result10)
    #<_sre.SRE_Match object; span=(11, 20), match='gogogogle'>'''

#模式修正符
'''
    #设定匹配的一些额外的规则。
    # re.A  或者re.ASCII    在ASCII模式下进行正则匹配操作  ASCII码只有数字字母下划线
    # re.U  或者re.UNICODE  在UNICODE模式下进行正则匹配操作  默认情况下
    # re.S  使得原子.可以匹配任意字符，包含\n
    # re.M  或者re.MULTILINE  匹配操作在多行模式下进行  都是与^和$相关
#以下暂缺
    # re.X  或者re.VERBOSE  匹配的时候忽略正则表达式中的空格或者注释
    # re.I  或者re.IGNORECASE 匹配过程中忽略大大小写

import re
#准备正则表达式
pattern1 = r'\w+'  #w是字母数字下划线
pattern2 = r'\w+'

pattern3 = r'e.b'
pattern4 = r'e.b'

pattern5 = r'^www'


#正则查找的字符串
url1 = '我love你他love我我也love大家'
url2 = '我love你他love我我也love大家'
url3 = 'google\nbaidu'
url4 = 'google\nbaidu'

url5 = 'www.baidu.com\nwww.google.com'


#匹配条件
result1 = re.search(pattern1,url1,re.U)
print(result1)
    #<_sre.SRE_Match object; span=(0, 20), match='我love你他love我我也love大家'>
result2 = re.findall(pattern2,url2,re.A)
print(result2)
    #['love', 'love', 'love']

result3 = re.findall(pattern3,url3,re.A)
print(result3)
    #[]    因为.可以匹配除了\n以外的任意字符（基础知识）
result4 = re.findall(pattern4,url4,re.S)
print(result4)
    #['e\nb']

result5 = re.findall(pattern5,url5,re.MULTILINE)
print(result5)
    #['www', 'www']
'''

#转义字符的应用
'''
    #字符串：\n  \r  \t  \\ ...
    #因为在正则的元字符和原子当中，使用了部分的符号作为语法，为了匹配这些符号的单纯字符格式，在正则表达式中添加\即可去掉意义，获取字符

#导入re模块
import re

#正则表达式
pattern1 = r'www.baidu.com'  #.可以代替任何字符,除了\n
pattern2 = r'www\.baidu\.com'  #去掉.在正则表达式中的功能
pattern3 = r'[百度]'  #[]的作用是在“百”中“度”任选其一
pattern4 = r'\[百度\]'  #去掉[]在正则表达式中的功能

#字符串
str1 = 'http://www1baidu1com'
str2 = 'http://www.baidu.com' #如果改成http://www1baidu1com就匹配不到了
str3 = 'www.baidu.com[百度]'
str4 = 'www.baidu.com[百度]'

#进行匹配操作
result1 = re.search(pattern1,str1)
print(result1)
    #<_sre.SRE_Match object; span=(0, 13), match='www1baidu1com'>
result2 = re.search(pattern2,str2)
print(result2)
    #<_sre.SRE_Match object; span=(7, 20), match='www.baidu.com'>
result3 = re.search(pattern3,str3)
print(result3)
    #<_sre.SRE_Match object; span=(14, 15), match='百'>
result4 = re.search(pattern4,str4)
print(result4)
    #<_sre.SRE_Match object; span=(13, 17), match='[百度]'>
'''

#扩展之后正则语法
'''
    # 1 (?Limsux)   多种模式修正符的应用    L不常用
    # 2 (?:)        取消单元存储功能   节省资源
    # 3 (?P<name>)  自定义模式单元的名称
    # 4 (?P=name)   获取自定义模式单元的内容
    # 5 (?#)        正则注释内容，解析器不会处理该内容(用的不多)
    # 6 (?=)        正向先行断言  （零宽断言）   有的话就匹配，没有就不匹配
            #正向 -> 有     负向 -> 相当于没有
            #先行 -> 向前/向右进行查找      后行 ->向后/向左进行查找
    # 7 (?!)        负向先行断言  （零宽断言）
            #正向 -> 有     负向 -> 相当于没有
            #先行 -> 向前/向右进行查找      后行 ->向后/向左进行查找
    # 8 (?<=)       正向后行断言（零宽断言）
            # 正向 -> 有     负向 -> 相当于没有
            # 先行 -> 向前/向右进行查找      后行 ->向后/向左进行查找
    # 9 (?<!)       负向后行断言（零宽断言）
            # 正向 -> 有     负向 -> 相当于没有
            # 先行 -> 向前/向右进行查找      后行 ->向后/向左进行查找
        #零宽断言注意事项
        #1.可以同时存在前行和后行
        #2.后行注意事项，宽度必须指定，不能是可变宽度
    # 10 (?(id/name)Y|N)    根据模式单元是否存在决定使用Y的规则（模式单元存在）或者是N的规则

#导入re模块
import re

#正则表达式
    #1 (?Limsux)  多种模式修正符的应用    L不常用
pattern1 = r'baidu'
pattern2 = r'(?imx)bai   du'    #i是不区分大小写，x是去除正则的空白
    #2 (?:)      取消单元存储功能
pattern3 = r'bai(du)'  #将()中的内容作为模式单元处理(这是自带的功能)
pattern4 = r'(bai)(du)'
pattern5 = r'bai(?:du)+'  #“?:”取消了()单元存储功能
    # 3 (?P<name>)  自定义模式单元的名称
pattern6 = r'<([a-z]+)>.*</\1>'     #\1是想取出整个模式单元中第一个内容
                                    #索引模式单元的应用
pattern7 = r'<(?P<biaoti>[a-z]+)>.*'
    # 4 (?P=name)   获取自定义模式单元的内容
pattern8 = r'<(?P<biaoti>[a-z]+)>.*</(?P=biaoti)>' #字典模式单元的存储
    # 5 (?#)        正则注释内容
pattern9 = r'(?i)bai(?#我就是个注释)du'
    # 6 (?=)        正向先行断言  （零宽断言）
pattern10 = r'lmonkey(?=\.com)'     #lmonkey后有没有.com，有的话就匹配，没有的话就不匹配
    # 7 (?!)        负向先行断言  （零宽断言）
pattern11 = r'lmonkey(?!\.com)'     #lmonkey后没有.com的都要
pattern12 = r'lmonkey\d(?!\.com)'
    # 8 (?<=)       正向后行断言（零宽断言）
pattern13 = r'(?<=xxyd\.)lmonkey\d'    #前面有xxyd的才要
    # 9 (?<!)       负向后行断言（零宽断言）
pattern14 = r'(?<!xxyd\.)lmonkey\d'     #前面没有xxyd的才要
    # 10 (?(id/name)Y|N)    根据模式单元是否存在决定使用Y的规则（模式单元存在）或者是N的规则
    #www.lmonkey.com
pattern15 = r'(www)?(?(1).*|\w+\.)'    #如果www存在，就把整个网址拿出来
pattern16 = r'(www)?(?(1).*|\w+\.)'    #用(1)来引用第一个模式单元

#字符串
    #1 (?Limsux)  多种模式修正符的应用    L不常用
str1 = 'www.BaiDu.com[百度]'
str2 = 'www.BaiDu.com[百度]'
    #2 (?:)      取消单元存储功能
str3 = 'www.baidu.com'
str4 = 'www.baidu.com'
str5 = 'www.baidudududududu.com'
    # 3 (?P<name>)  自定义模式单元的名称
str6 = '<title>百度</title><body>www.baidu.com</body>'
str7 = '<title>百度</title><body>www.baidu.com</body>'
    # 4 (?P=name)  获取自定义模式单元的内容
str8 = '<title>百度</title><body>www.baidu.com</body>'
    # 5 (?#)        正则注释内容
str9 = 'www.baidu.com'
    # 6 (?=)        正向先行断言  （零宽断言）
str10 = 'www.lmonkey.cn-www.lmonkey.com-www.lmonkey.net-www.lmonkey.org'
    # 7 (?!)        负向先行断言  （零宽断言）
str11 = 'www.lmonkey.cn-www.lmonkey.com-www.lmonkey.net-www.lmonkey.org'
str12 = 'www.lmonkey1.cn-www.lmonkey2.com-www.lmonkey3.net-www.lmonkey4.org'
    # 8 (?<=)       正向后行断言（零宽断言）
str13 = 'www.lmonkey1.cn-bbs.lmonkey2.com-xxyd.lmonkey3.net-aaa.lmonkey4.org'
    # 9 (?<!)       负向后行断言（零宽断言）
str14 = 'www.lmonkey1.cn-bbs.lmonkey2.com-xxyd.lmonkey3.net-aaa.lmonkey4.org'
    # 10 (?(id/name)Y|N)    根据模式单元是否存在决定使用Y的规则（模式单元存在）或者是N的规则
str15 = 'www.lmonkey.com'
str16 = 'bbs.lmonkey.com'


#进行匹配操作
    #1 (?Limsux)  多种模式修正符的应用    L不常用
result1 = re.search(pattern1,str1,re.I)
print(result1)#<_sre.SRE_Match object; span=(4, 9), match='BaiDu'>
result2 = re.search(pattern2,str2)
print(result2)#<_sre.SRE_Match object; span=(4, 9), match='BaiDu'>
    #2 (?:)      取消单元存储功能
result3 = re.search(pattern3,str3)
print(result3)
print(result3.groups())#<_sre.SRE_Match object; span=(4, 9), match='baidu'>
                        #('du',)
result4 = re.search(pattern4,str4)
print(result4.groups())#('bai', 'du')
result5 = re.search(pattern5,str5)
print(result5)
print(result5.groups())#<_sre.SRE_Match object; span=(4, 19), match='baidudududududu'>
                        #()
    # 3 (?P<name>)  自定义模式单元的名称
result6 = re.search(pattern6,str6)
print(result6)
print(result6.groups())#<_sre.SRE_Match object; span=(0, 17), match='<title>百度</title>'>
                        #('title',)
result7 = re.search(pattern7,str7)
print(result7)
print(result7.groupdict())    #<_sre.SRE_Match object; span=(0, 43), match='<title>百度</title><body>www.baidu.com</body>'>
                              #{'biaoti': 'title'}
    # 4 (?P=name)  获取自定义模式单元的内容
result8 = re.search(pattern8,str8)
print(result8)
print(result8.groupdict())      #<_sre.SRE_Match object; span=(0, 17), match='<title>百度</title>'>
                                #{'biaoti': 'title'}
    # 5 (?#)        正则注释内容
result9 = re.search(pattern9,str9)
print(result9)                  #<_sre.SRE_Match object; span=(4, 9), match='baidu'>
    # 6 (?=)        正向先行断言  （零宽断言）
result10 = re.search(pattern10,str10)
print(result10)                 #<_sre.SRE_Match object; span=(19, 26), match='lmonkey'>
    # 7 (?!)        负向先行断言  （零宽断言）
result11 = re.search(pattern11,str11)
print(result11)                 #<_sre.SRE_Match object; span=(4, 11), match='lmonkey'>
result12 = re.findall(pattern12,str12)
print(result12)                 #['lmonkey1', 'lmonkey3', 'lmonkey4']
    # 8 (?<=)       正向后行断言（零宽断言）
result13 = re.search(pattern13,str13)
print(result13)                 #<_sre.SRE_Match object; span=(38, 46), match='lmonkey3'>
    # 9 (?<!)       负向后行断言（零宽断言）
result14 = re.findall(pattern14,str14)
print(result14)                 #['lmonkey1', 'lmonkey2', 'lmonkey4']
    # 10 (?(id/name)Y|N)    根据模式单元是否存在决定使用Y的规则（模式单元存在）或者是N的规则
result15 = re.search(pattern15,str15)
print(result15)                 #<_sre.SRE_Match object; span=(0, 15), match='www.lmonkey.com'>
result16 = re.search(pattern16,str16)
print(result16)                 #<_sre.SRE_Match object; span=(0, 4), match='bbs.'>
'''

#正则表达式的书写
'''
#1.用户名（简单的正则）
    #a.设定规则（有字符，必须3个字符以上，可以使用数字，不能使用特殊符号，可以使用_）
    #b.书写以下符合规则的实例
        #congha
        #congha666
        #cong_ha
        #cong_666
    #c.正则书写
    #d.验证正则（正确/错误）
#2.ip地址
    #a.设定规则（四个数字段，每个数字段用.分割，数字范围0~255）
    #b.书写以下符合规则的实例
        #192.168.0.1
        #127.0.0.1
        #0.0.0.0
        #255.255.255.255
    #c.正则书写
    #d.验证正则（正确/错误）
#3.电话号码
    #a.设定规则(纯数字：11位数字，第2,3个号码有限制)
    #b.书写以下符合规则的实例
        # 13012345678
        # 13112345678
        # ...
        # 13912345678

        # 147...

        # 15112345678
        # ...
        # 15912345678

        # 170...
        # ...
        # 179...

        # 180...
        # ...
        # 189...
    #c.正则书写
    #d.验证正则（正确/错误）
#4.身份证
    # a.设定规则(18位内容，数字和字母X组成，X只能在最后一位，部分内容需要年月日的需求)
    # b.书写以下符合规则的实例
        #110345(地址) 19991224(出生日期) 123(顺序码) 9(校验码)
        #120234 20000509 123 x
    # c.正则书写
    # d.验证正则（正确/错误）

import re
#正则表达式
    #1.用户名
pattern1 = r'^\w{3,}$'     #
pattern2 = r'^\w{3,}$'
    #2.ip地址
#pattern3 = r'\d(?#1位数)|\d[1-9]\d(?#2位数) | 1\d{2}(?#3位数100-199) | 2[0-4]\d (?#3位数200-249) | 25[0-5] \.'
#pattern3 = r'^((?:\d)|(?:[1-9]\d)|(?:1\d{2})|(?:2[0-4]\d)|(?:25[0-5]))\.$'
pattern3 = r'^((?:[1-9]?|1\d|2[0-4]\d)|(?:25[0-5]))\.$'     #简化合并 ”提取公因式“
pattern4 = r'^(((?:([1-9]?|1\d|2[0-4])\d)|(?:25[0-5]))\.){3}((?:([1-9]?|1\d|2[0-4])\d)|(?:25[0-5]))$'
    #3.电话号码
#pattern5 = r'130|131|147|15\d|17\d|18\d\d{8}'
pattern5 = r'1(47|[3578]\d) \d{8}'   # 合并   这里有个空格，可以在re.search中用re.X去掉空格
    #4.身份证
pattern6 = r'\d{6}  (18|19|[2-9]\d)\d{2}  (0[1-9]|1[0-2])  (0[1-9]|[12]\d|3[01])  \d{3}(\d|x)'


#检测字符串
    # 1.用户名
str1 = 'congha'
str2 = 'ch'   #错误的用户名
    #2.ip地址
str3 = '00.'
str3_1 = '199.'
str4 = '192.168.0.1'
    # 3.电话号码
str5 = '17012345678'
    #4.身份证
str6 = '11034519930502123x'



#匹配操作
    # 1.用户名
result1 = re.search(pattern1,str1)
print(result1)      #<_sre.SRE_Match object; span=(0, 6), match='congha'>
result2 = re.search(pattern2,str2)
print(result2)      #None
    #2.ip地址
result3 = re.search(pattern3,str3)
print(result3)      #None
result3_1 = re.search(pattern3,str3_1)
print(result3_1)    #<_sre.SRE_Match object; span=(0, 4), match='199.'>
result4 = re.search(pattern4,str4)
print(result4)      #<_sre.SRE_Match object; span=(0, 11), match='192.168.0.1'>
    # 3.电话号码
result5 = re.search(pattern5,str5,re.X)
print(result5)      #<_sre.SRE_Match object; span=(0, 11), match='17012345678'>
    #4.身份证
result6 = re.search(pattern6,str6,re.X)
print(result6)      #<_sre.SRE_Match object; span=(0, 18), match='11034519930502123x'>
print(result6.groups())
'''

#re模块：正则表达式的专用模块，提供正则相关的操作方法
'''
#re模块的方法
    #complie()   1.编译正则表达式，获取正则表达式对象   2.可以循环利用，提高程序效率
            #格式：re.compile（正则字符串，模式修正符）
            #返回值：正则对象
    #escape()   对字符串进行转义处理(仅处理非数字和字母的字符串)
            #格式：re.escape(字符串)
            #结果：字符串
    #findall()  对字符串进行正则匹配，获取所有匹配的内容结果
            #格式：re.findall(正则表达式，匹配字符串，模式修正符)
            #结果：列表
    #finditer() 对字符串进行正则匹配，获取所有匹配的结果对象
            # 格式：re.finditer(正则表达式，匹配字符串，模式修正符)
            # 结果：包含所有匹配结果的迭代器
    #match()    对字符串的开头对字符串进行正则匹配,当匹配到第一个结果时就停止匹配，返回结果对象
            #格式：re.match(正则表达式,匹配的字符串,模式修正符)
            #结果：匹配结果对象
    #search()   是在任意位置对字符串进行正则匹配,当匹配到第一个结果时就停止匹配，返回结果对象
            # 格式：re.match(正则表达式,匹配的字符串,模式修正符)
            # 结果：匹配结果对象
    #split()    使用正则表达式切割字符串
            #格式：re.split(正则表达式,匹配的字符串,最大切割次数)
            #结果：切割后的字符串组成的列表
    #sub()      正则替换
            #格式：re.sub(正则表达式，替换的字符串，匹配的字符串,替换次数)
            #结果：匹配字符串被替换后的字符串
    #subn()      正则替换
            #格式：re.subn(正则表达式，替换的字符串，匹配的字符串,替换次数)
            #结果：由替换之后的字符串和替换次数组成的元组！
#导入re模块
import re

#compile()    1.编译正则表达式，获取正则表达式对象   2.可以循环利用，提高程序效率
pattern1 = r'\d{13}'
print(pattern1,type(pattern1))              #\d{13} <class 'str'>

pattern1_obj = re.compile(pattern1,re.I)
print(pattern1_obj,type(pattern1_obj))      #re.compile('\\d{13}', re.IGNORECASE) <class '_sre.SRE_Pattern'>

# escape()   对字符串进行转义处理
s1= 'how old are you? i am 25'
result1 = re.escape(s1)
print(result1)               #how\ old\ are\ you\?\ i\ am\ 25

# findall()  对字符串进行正则匹配，获取所有匹配的内容结果
pattern2 = r'baidu'
s2 = 'www.baidu.com-www.BAIDU.com-www.BaiDu.com'
result2 = re.findall(pattern2,s2,re.I)
print(result2)               #['baidu', 'BAIDU', 'BaiDu']

# finditer()
pattern3 = r'baidu'
s3 = 'www.baidu.com-www.BAIDU.com-www.BaiDu.com'
result3 = re.finditer(pattern3,s3,re.I)
print(result3)      #<callable_iterator object at 0x00000185E6884278>

for i in result3:
    print(i)       #<callable_iterator object at 0x0000016B4FB242B0>
    # <_sre.SRE_Match object; span=(4, 9), match='baidu'>
    # <_sre.SRE_Match object; span=(18, 23), match='BAIDU'>
    # <_sre.SRE_Match object; span=(32, 37), match='BaiDu'>

#search()
pattern4 = r'lmonkey'
str4 = 'www.lmonkey.com;mp4.lmonkey.com;bbs.lmonkey.com'
result4 = re.search(pattern4,str4)
print(result4)          #<_sre.SRE_Match object; span=(4, 11), match='lmonkey'>
print(type(result4))    #<class '_sre.SRE_Match'>

#match()
pattern5 = r'lmonkey'
str5 = 'lmonkey.com;mp4.lmonkey.com;bbs.lmonkey.com'
result5 = re.match(pattern5,str5)
print(result5)          #<_sre.SRE_Match object; span=(0, 7), match='lmonkey'>
print(type(result5))    #<class '_sre.SRE_Match'>

#split()    使用正则表达式切割字符串
s6 = '10世9贫，凑得8两7钱6分5毫4厘，况且3心2意，1等下流'
pattern6 = r'\d+'   #按照数字分割
result6 = re.split(pattern6,s6)
result6_2 = re.split(pattern6,s6,3)  #切割3次
print(result6)          #['', '世', '贫，凑得', '两', '钱', '分', '毫', '厘，况且', '心', '意，', '等下流']
print(result6_2)          #['', '世', '贫，凑得', '两7钱6分5毫4厘，况且3心2意，1等下流']

#sub()      正则替换
s7 = '蜡笔小新的爸爸是野原广志，蜡笔小新的妈妈是野原美伢，蜡笔小新的妹妹是野原葵'
pattern7 = r'蜡笔小新'
replace_s = '野原新之助'
result7 = re.sub(pattern7,replace_s,s7,2)   #替换两次
print(result7)      #野原新之助的爸爸是野原广志，野原新之助的妈妈是野原美伢，蜡笔小新的妹妹是野原葵

#subn()      正则替换
s8 = '蜡笔小新的爸爸是野原广志，蜡笔小新的妈妈是野原美伢，蜡笔小新的妹妹是野原葵'
pattern8 = r'蜡笔小新'
replace_s = '野原新之助'
result8 = re.subn(pattern8,replace_s,s8,2)   #替换两次
print(result8)      #('野原新之助的爸爸是野原广志，野原新之助的妈妈是野原美伢，蜡笔小新的妹妹是野原葵', 2)
'''

#正则对象的方法(借助compile方法获取)   rx代表正则对象
'''
    #findall()  使用正则表达式对指定的字符串进行匹配，获取所有匹配结果组成的列表
        #格式：rx.findall(要匹配的字符串)
        #结果：所有匹配结果组成的列表
    #finditer() 使用正则表达式对象对指定的字符串进行匹配，获取所有匹配结果对象组成的迭代器
        #格式：rx.finditer(要匹配的字符串)
        #结果：迭代器
    #match()    使用正则表达式对象对指定的字符串开头进行匹配，返回第一次匹配到的结果对象
        #格式：rx.match(要匹配的字符串)
        #结果：匹配结果对象
    #search()   使用正则表达式对象对指定的字符串进行匹配，返回第一次匹配到的结果对象
        #格式：rx.search(要匹配的字符串)
        #结果：匹配结果对象
    #split()    正则切割字符串
        # 格式：rx.split(s)
        # 结果：切割之后的字符组成的列表
    #sub()      正则替换
        #格式：rx.sub(要替换承成的内容，被替换的字符串，替换次数)
        #结果：替换之后的字符串
    #subn()     正则替换
        #格式：rx.subn(要替换承成的内容，被替换的字符串，替换次数)
        #结果：替换之后的字符串和次数组成的元组

    # flags         获取当前正则对象的模式修正符
    # pattern       获取正则表达式的字符串格式
    # groups        模式单元的个数
    # groupindex




import re
#正则对象
#匹配操作1 re模块  （正则表达式，字符串）   =>  结果对象
#匹配操作2 正则表达式对象 （字符串）   =>  结果对象

#findall()   使用正则表达式对指定的字符串进行匹配，获取所有匹配结果组成的列表
s1 = 'www.baidu.com;mp4.BAIDU.com;image.BaiDu.com'
rx1 = re.compile(r'baidu',re.I)
print(rx1,type(rx1))      #re.compile('baidu', re.IGNORECASE) <class '_sre.SRE_Pattern'>
result1 = rx1.findall(s1)
print(result1)          #['baidu', 'BAIDU', 'BaiDu']

#finditer()   使用正则表达式对指定的字符串进行匹配，获取所有匹配结果组成的列表
s2 = 'www.baidu.com;mp4.BAIDU.com;image.BaiDu.com'
rx2 = re.compile(r'baidu',re.I)
print(rx2,type(rx2))      #re.compile('baidu', re.IGNORECASE) <class '_sre.SRE_Pattern'>
result2 = rx2.finditer(s2)
print(result2)          #<callable_iterator object at 0x0000022BB0FE4240>

for i in result2:
    print(i)
    # <_sre.SRE_Match object; span=(4, 9), match='baidu'>
    # <_sre.SRE_Match object; span=(18, 23), match='BAIDU'>
    # <_sre.SRE_Match object; span=(34, 39), match='BaiDu'>

#match()    使用正则表达式对象对指定的字符串开头进行匹配，返回结果对象
s3 = 'baidu.com;mp4.BAIDU.com;image.BaiDu.com'
rx3 = re.compile(r'baidu',re.I)
print(rx3,type(rx3))
result3 = rx3.match(s3)
print(result3)      #<_sre.SRE_Match object; span=(0, 5), match='baidu'>

#search()
s4 = 'tieba.baidu.com;mp4.BAIDU.com;image.BaiDu.com'
rx4 = re.compile(r'baidu',re.I)
print(rx4,type(rx4))
result4 = rx4.search(s4)
print(result4)      #<_sre.SRE_Match object; span=(6, 11), match='baidu'>

#split()    正则切割字符串
s5 = '10世9贫，凑得8两7钱6分5毫4厘，况且3心2意，1等下流'
rx5 = re.compile(r'\d+')
print(rx5,type(rx5))
result5 = rx5.split(s5)
print(result5)      #['', '世', '贫，凑得', '两', '钱', '分', '毫', '厘，况且', '心', '意，', '等下流']

#sub()      正则替换
s6 = '蜡笔小新的爸爸是野原广志，蜡笔小新的妈妈是野原美伢，蜡笔小新的妹妹是野原葵'
rx6 = re.compile(r'的')
print(rx6,type(rx6))
result6 = rx6.sub('の',s6,2)
print(result6)      #蜡笔小新の爸爸是野原广志，蜡笔小新の妈妈是野原美伢，蜡笔小新的妹妹是野原葵

#subn()      正则替换
s7 = '蜡笔小新的爸爸是野原广志，蜡笔小新的妈妈是野原美伢，蜡笔小新的妹妹是野原葵'
rx7 = re.compile(r'的')
print(rx7,type(rx7))
result7 = rx7.subn('の',s7,2)
print(result7)      #('蜡笔小新の爸爸是野原广志，蜡笔小新の妈妈是野原美伢，蜡笔小新的妹妹是野原葵', 2)


# flags 获取当前正则对象的模式修正符
rx8 = re.compile(r'\w+',re.I)
print(rx8.flags)     #34     34是模式修正符的编号

# pattern   获取正则表达式的字符串格式
rx9 = re.compile(r'(?sx)\w+',re.I)
print(rx9.pattern)      #(?sx)\w+

# groups
rx10 = re.compile(r'(?sx)\w+(\d)\S')
print(rx10.groups)      #1    说明有1个模式单元(\d)

# groupindex
rx11 = re.compile(r'(?sx)(?P<a>\w+)(\d)(?P<b>\S)')
print(rx11.groupindex)  #{'a': 1, 'b': 3}
'''

#正则对象的扩展用法(re下不可以这么用)
'''
    # findall(s,开始位置,介绍位置)
    # finditer(s,开始位置,介绍位置)
    # match(s,开始位置,介绍位置)
    # search(s,开始位置,介绍位置)
import re

s = 'https://www.lmonkey.com'
pattern = r'lmonkey'  #正则表达式
rx = re.compile(pattern)
result = rx.findall(s)
print(result)           #['lmonkey']

s2 = 'https://www.lmonkey.com'
pattern2 = r'lmonkey'  #正则表达式
rx2 = re.compile(pattern2)
result2 = rx2.findall(s2,0,10)    #匹配0-10的字符
print(result2)          #[]

s3 = 'https://www.lmonkey.com'
pattern3 = r'lmonkey'  #正则表达式
rx3 = re.compile(pattern2)
result3 = rx3.findall(s3,10)    #匹配10以后的字符
print(result3)          #['lmonkey']
'''