正则表达式

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

Python 使用 re 模块提供正则表达式功能，它提供 Perl 风格的正则表达式模式。

re.match()函数

re.match 尝试从字符串的 起始位置 匹配一个模式，匹配成功的话返回一个匹配的对象，否则返回None。

函数语法：

 re.match( pattern ,  string  [,flags=0] )

参数：

• pattern：匹配的正则表达式

• string：要匹配的字符串

• flags：可选参数，标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等

1. >>import re

2. >>print(re.match('www','www.baidu.com'))

3. >>print(re.match('baidu','www.baidu.com'))

4. >>print(re.match('www','www.baidu.com').span()) #返回匹配对象在字符串中的索引，返回元组类型的数据

5. 
   

6. <re.Match object; span=(0, 3), match='www'>

7. None

8. (0, 3)

 re.search()函数

re.search 扫描整个字符串并返回第一个成功的匹配。匹配成功 re.search 方法返回一个匹配的对象，否则返回None。

函数语法：

 re.search( pattern , string   [,flags=0] )

参数：

• pattern：匹配的正则表达式

• string：要匹配的字符串

• flags：可选参数，标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等

1. >>import re

2. >>print(re.search('www','www.baidu.com').span())

3. >>print(re.search('www','www.baidu.com').group(0)

4. >>print(re.search('com','www.baidu.com').span())

5. (0, 3)

6. www

7. (10, 13)

re.match()和re.search()的联系和区别 

re.match只匹配字符串的开始，如果字符串开始不符合正则表达式，则匹配失败，函数返回None；而re.search匹配整个字符串，直到找到一个匹配。

 不管是re.match() 还是 re.search() , 我们都可以使用 group(num) 或 groups() 匹配对象函数来获取匹配表达式。

1. import re

2. line = "Cats are smarter than dogs"

3. matchObj = re.match( r'(.*) are (.*?) .*', line, re.M|re.I)

4. 或 matchObj = re.searcch( r'(.*) are (.*?) .*', line, re.M|re.I)

5. 
   

6. if matchObj:

7. print ("matchObj.group() : ", matchObj.group())

8. print ("matchObj.group(1) : ", matchObj.group(1))

9. print ("matchObj.group(2) : ", matchObj.group(2))

10. else:

11. print ("No match!!")

12. ################################################################

13. matchObj.group() : Cats are smarter than dogs

14. matchObj.group(1) : Cats

15. matchObj.group(2) : smarter

检索和替换(re.sub)

Python 的 re 模块提供了 re.sub 用于替换字符串中的匹配项

re.sub(pattern , repl , string  [, count=0] )

参数：

• pattern：正则中的模式字符串

• repl：替换成的字符串，也可以是一个函数

• string：要被替换的字符串

• count：模式匹配后替换的最大次数，默认0表示替换所有的匹配

1. import re

2. 
   

3. a="hello,word!hello,word!"

4. ret=re.sub("ll","dd",a) #将a中所有的ll替换成dd

5. ret2=re.sub("ll","dd",a,count=1) #将a中第一个ll替换成dd

6. print(ret)

7. print(ret2)

8. ########################################

9. heddo,word!heddo,word!

10. heddo,word!hello,word!

11. 
    

12. 
    

13. #将./之间的任何数字替换成0

14. import re

15. ip="192.168.1.3/24"

16. ip=re.sub(r"\.([0-9]+)/",".0/",a)

17. print(ip)

18. #####################################

19. 192.168.1.0/24

re.compile()函数

compile 函数用于编译正则表达式，生成一个正则表达式（ Pattern ）对象，供 match() 和 search() 这两个函数使用。

re.compile( pattern [, flags] )

参数

• pattern：一个字符串形式的正则表达式

• flags：可选参数，表示匹配模式，比如忽略大小写，多行模式

1. import re

2. pattern=re.compile(r'^h') #匹配开头是h的

3. m=pattern.match('hello')

4. print(m)

5. ###################################

6. <re.Match object; span=(0, 1), match='h'>

re.findall()函数

在字符串中找到正则表达式所匹配的所有子串，并返回一个列表，如果没有找到匹配的，则返回空列表。

注意： match 和 search 是匹配一次， findall 是匹配所有。

findall ( pattern , string  [, pos ] [, endpos ] )

• pattern：正则中的模式字符串

• string：待匹配的字符串

• pos：可选参数，指定字符串的起始位置，默认为0

• endpos：可选参数，指定字符串的结束位置，默认为字符串的长度

1. import re

2. a="hello,word!hello,word!"

3. m=re.findall("ll",a)

4. print(m)

5. ################################

6. ['ll', 'll']

7. 
   

8. 
   

9. 
   

10. import re

11. pattern=re.compile('ll')

12. m=pattern.findall("hello,word!hello,word!")

13. print(m)

14. ###################################

15. ['ll', 'll']

16. 
    

17. 
    

18. #匹配./之间的所有数字

19. import re

20. ip="192.168.1.213/24"

21. a=re.findall("\.([0-9]+)/",ip)

22. print(a)

23. #####################

24. ['213']

findall和sub函数正则匹配时的区别

re.finditer()函数

和 findall 类似，在字符串中找到正则表达式所匹配的所有子串，并把它们作为一个迭代器返回。

finditer( pattern , string  [, flags] )

参数

• pattern：匹配的正则表达式

• string：要匹配的字符串

• flags：可选参数，标志位，用于控制正则表达式的匹配方法，如：是否区分大小写，多行匹配等等

1. import re

2. it=re.finditer("ll","hello,word!hello,word!")

3. for i in it:

4. print(i.group())

5. ########################################

6. ll

7. ll

re.split()函数 

split 方法按照能够匹配的子串将字符串分割后返回列表型数据

finditer( pattern , string  [,maxsplit]  [,flags=0]  )

参数

• pattern：匹配的正则表达式

• string：要匹配的字符串

• maxspliit：分隔次数，maxsplit=1分隔一次，默认为0，不限制次数

• flags：标志位，用于控制正则表达式的匹配方法，如：是否区分大小写，多行匹配等等

1. import re

2. a=re.split('ll',"hello,hello,hello")

3. print(a)

4. ######################################

5. ['he', 'o,he', 'o,he', 'o']

正则表达式对象 

re.RegexObject

re.compile() 返回 RegexObject 对象。

re.MatchObject

group() 返回被 RE 匹配的字符串。

• start() 返回匹配开始的位置

• end() 返回匹配结束的位置

• span() 返回一个元组包含匹配 (开始,结束) 的位置

正则表达式标志位

正则表达式可以包含一些可选标志修饰符来控制匹配的模式。修饰符被指定为一个可选的标志。多个标志可以通过按位 OR(|) 它们来指定。如 re.I | re.M 被设置成 I 和 M 标志

比如：

url=re.findall(r"window.location.href=['\"](.*?)['\"]",html,re.I|re.M)

 正则表达式模式

模式字符串使用特殊的语法来表示一个正则表达式：

字母和数字表示他们自身。一个正则表达式模式中的字母和数字匹配同样的字符串。

多数字母和数字前加一个反斜杠时会拥有不同的含义。

标点符号只有被转义时才匹配自身，否则它们表示特殊的含义。

反斜杠本身需要使用反斜杠转义。

由于正则表达式通常都包含反斜杠，所以你最好使用原始字符串来表示它们。模式元素(如 r'\t'，等价于 \\t )匹配相应的特殊字符。

下表列出了正则表达式模式语法中的特殊元素。如果你使用模式的同时提供了可选的标志参数，某些模式元素的含义会改变

正则表达式实例 

字符匹配

字符类

特殊字符类

本文转发自原创作者谢公子，转载前已取得原作者同意，如二次转载请务必联系原作者。

原文链接：hhttps://blog.csdn.net/qq_36119192/article/details/83751695