Python3笔记--Re模块(正则表达式)

正则表达式是一个特殊的字符序列，它能帮助你方便的检查一个字符串是否与某种模式匹配。

一些功能函数

　　

1. re.search函数

   原型：search(pattern,string,flags=0)
   参数：
   pattern:匹配的正则表达式，
   string:要匹配的字符串，
   flags:标志位，用于控制正则表达式的匹配方式

   功能：扫描整个字符串，并返回第一个成功的匹配Match对象

   import re
   print(re.search("sunck","good man is sunCk.sunck is nice."))
   #<re.Match object; span=(18, 23), match='sunck'>

    

    

2. re.match函数

   原型：match(pattern,string,flags=0)
   参数：
   pattern:匹配的正则表达式，
   string:要匹配的字符串，
   flags:标志位，用于控制正则表达式的匹配模式
   
   功能：尝试从字符串的起始位置匹配，成功返回Match对象.
   如果不是起始位置匹配成功，还是返回None，有一定局限性

   import re
   print(re.match("www","www.baidu.com"))
   #<re.Match object; span=(0, 3), match='www'>

    

3. re.findall函数

   原型：findall(pattern,string,flags=0)
   参数：
   pattern:匹配的正则表达式，
   string:要匹配的字符串，
   flags:标志位，用于控制正则表达式的匹配方式

   功能：扫描整个字符串，并返回匹配的结果的列表

   print(re.findall("sunck","good man is sunck!sunck is good man."))
   #['sunck', 'sunck']

    

4. re.finditer函数

   原型：finditer(pattern,string,flags=0)
   参数：
   pattern:匹配的正则表达式，
   string:要匹配的字符串，
   flags:标志位，用于控制正则表达式的匹配方式

   功能：与findall类似，扫描整个字符串，并返回一个迭代器

   str2="sunck is a good man!sunck is a nice man!sunck is a handsome man!"
   res=re.finditer(r"sunck",str2)
   #这里字符串前r表示不转义，使用真实字符
   while True:
       #防止迭代器为空时的报错
       try:
           n=next(res)
           print(n)
       except:
           break
   #<re.Match object; span=(0, 5), match='sunck'>
   #<re.Match object; span=(20, 25), match='sunck'>
   #<re.Match object; span=(40, 45), match='sunck'>

    

    

5. re.sub()与
   re.subn()函数

   字符串的替换和修改
   sub(pattern,repl,string,count=0)
   subn(pattern,repl,string,count=0)
   pattern:正则表达式（规则）
   repl:指定的用来替换的字符串
   string:目标字符串
   count:最多替换次数
   功能：在目标字符串中以正则表达式的规则匹配字符串，
   再把它们替换成指定的字符串。可以指定替换的次数。0为默认替换所有。
   sub与subn区别：前者返回第一个被替换的字符串，后者返回一个元组，
   元组中第一个元素为替换的字符串，第二个元素表示被替换的次数。

   str3 = r'https://www.baidu.com/s?word=ts&tn=78000241_11_hao_pg'
   res = re.sub('/s.*','',str3)
   print(res)
   #https://www.baidu.com

    

6. re.split(pattern,string)
   
   字符串切割
   用re进行字符串切割比原生的字符串方法split()可更灵活定义切割的规则

   str4 = "sunck     is  a good  man"
   print(str4.split(" "))
   print(re.split(r" +",str4))
   #['sunck', '', '', '', '', 'is', '', 'a', 'good', '', 'man']
   #['sunck', 'is', 'a', 'good', 'man']

    

7. re.compile函数

   用以编译：
   re.compile(pattern,flags=0)
   pattern:要编译的正则表达式

   re_telephon = re.compile(r"\d{11}")
   print(re_telephon.findall('188888888888888'))
   #['18888888888']

    

元字符

1. .(点) （规则里的.元字符）可以是任何一个字符，匹配任意除换行符"\n"外的字符

2. \ 反斜杠后边跟元字符去除特殊功能；（即将特殊字符转义成普通字符），2.反斜杠后边跟普通字符实现特殊功能；（即预定义字符）

3. *（规则里的*元字符）前面的一个字符可以是0个或多个原本字符，匹配前一个字符0或多次，贪婪匹配前导字符有多少个就匹配多少个，如果规则里只有一个分组，尽量避免用*否则会有可能匹配出空字符串

4. +（规则里的+元字符）前面的一个字符可以是1个或多个原本字符，匹配前一个字符1次或无限次，贪婪匹配前导字符有多少个就匹配多少个

5. ?（规则里的?元字符）前面的一个字符可以是0个或1个原本字符，匹配一个字符0次或1次，还有一个功能是可以防止贪婪匹配，详情见非贪婪匹配

6. ^ 匹配字符串开头。在多行模式中匹配每一行的开头，注意：^元字符如果写到[]字符集里就是反取,单独在表达式中使用就是匹配开头

7. $ 匹配字符串末尾，在多行模式中匹配每一行的末尾

8. | 或，或就是前后其中一个符合就匹配

9. {}   （规则里的 {} 元字符）前面的一个字符，是自定义字符数，位数的原本字符，{m}匹配前一个字符m次，{m,n}匹配前一个字符m至n次，若省略n，则匹配m至无限次，{0,}匹配前一个字符0或多次,等同于*元字符，{+,}匹配前一个字符1次或无限次,等同于+元字符，{0,1}匹配前一个字符0次或1次,等同于?元字符

10. []    （规则里的 [] 元字符）对应位置是[]里的任意一个字符就匹配，字符集。对应的位置可以是字符集中任意字符。字符集中的字符可以逐个列出，也可以给出范围，如[abc]或[a-c]。[^abc]表示取反，即非abc。所有特殊字符在字符集中都失去其原有的特殊含义。用\反斜杠转义恢复特殊字符的特殊含义。

11. ()   也就是分组匹配，()里面的为一个组也可以理解成一个整体，如果()后面跟的是特殊元字符如   (adc)*   那么*控制的前导字符就是()里的整体内容，不再是前导一个字符

预定义字符集

1. \d                  匹配数字，类似[0-9]

2. \D                  匹配非数字，类似[^0-9]

3. \w                  匹配任意数字、字母和下划线,类似[0-9a-zA-Z_]

4. \W                  匹配非数字、字母和下划线,类似[^0-9a-zA-Z_]

5. \s                  匹配任意空白字符（空格、换行、回车、换页、制表），类似[ \f\n\r\t]

6. \S                  匹配任意非空白字符（空格、换行、回车、换页、制表），类似[^ \f\n\r\t]

7. \A         　　     匹配字符串开始，和^区别是，即使在re.M模式下它也不会匹配它行的行首

8. \Z                  匹配字符串结束，和$区别是，即使在re.M模式下它也不会匹配它行的行尾

9. \b                  匹配一个单词的边界，也就是单词和空格间的位置

10. \B                  匹配非单词边界

    print(re.search(r"er\b","never"))
    print(re.search(r"er\b","nerve"))
    print(re.search(r"er\B","never"))
    print(re.search(r"er\B","nerve"))
    #<re.Match object; span=(3, 5), match='er'>
    #None
    #None
    #<re.Match object; span=(1, 3), match='er'>

     

正则匹配模式

　　

1. re.I 　 　忽略大小写
2. re.L 　 　做本地化识别
3. re.M 　　多行匹配，影响^(匹配行首)和$(匹配行尾)
4. re.S 　 　使.点匹配包括换行符在内的所有字符
5. re.U 　　根据Unicode字符集解析字符，影响\w,\W,\b,\B
6. re.X　　 使我们以更灵活的格式理解正则表达式

 

匹配多个字符

说明：下方的x,y,z均为假设的普通字符，不是正则表达式的元字符
(xyz) 匹配小括号内的xyz(作为一个整体去匹配)

x?　　     匹配0个或1个x
x* 　      匹配0个或任意多个字符（换行符除外）
x+　       匹配最少一个x
x{n}　     匹配确定的n个x
x{n,}　    匹配最少n个x
x{n,m} 　  匹配最少n个最多m个x.注意：n<=m
x|y 　   　|表示或，匹配的是x或y

 

print(re.findall(r"(sunck)","suncks is a good man,is nice man sunck "))
#['sunck', 'sunck']
print(re.findall(r"a?","aaa"))
#['a', 'a', 'a', '']
print(re.findall(r"a*","aaabaaaa"))
#['aaa', '', 'aaaa', '']
print(re.findall(r"a+","aaaabaaaaaaaa"))
#['aaaa', 'aaaaaaaa']
print(re.findall(r"a{3}","aaabaa"))
#['aaa']
print(re.findall(r"a{3,}","aaaaaaabaa"))
#['aaaaaaa']
print(re.findall(r"(s|Sunck)",'sunck--Sunck'))
#['s', 'Sunck']