python 正则表达式使用

虽然之前在linux中已经学习了一些正则的用法。最近在莫烦教程中学习爬虫，所以在莫烦教程中复习了正则。由此记录
参考：莫烦python教程正则

 

1.类型匹配

• \d : 任何数字
• \D : 不是数字
• \s : 任何 white space, 如 [\t\n\r\f\v]
• \S : 不是 white space
• \w : 任何大小写字母, 数字和 “” [a-zA-Z0-9]
• \W : 不是 \w
• \b : 空白字符 (只在某个字的开头或结尾)
• \B : 空白字符 (不在某个字的开头或结尾)
• \\ : 匹配 \
• . : 匹配任何字符 (除了 \n)
• ^ : 匹配开头
• $ : 匹配结尾
• ? : 前面的字符可有可无

# \d : decimal digit
print(re.search(r"r\dn", "run r4n"))           # <_sre.SRE_Match object; span=(4, 7), match='r4n'>
# \D : any non-decimal digit
print(re.search(r"r\Dn", "run r4n"))           # <_sre.SRE_Match object; span=(0, 3), match='run'>
# \s : any white space [\t\n\r\f\v]
print(re.search(r"r\sn", "r\nn r4n"))          # <_sre.SRE_Match object; span=(0, 3), match='r\nn'>
# \S : opposite to \s, any non-white space
print(re.search(r"r\Sn", "r\nn r4n"))          # <_sre.SRE_Match object; span=(4, 7), match='r4n'>
# \w : [a-zA-Z0-9_]
print(re.search(r"r\wn", "r\nn r4n"))          # <_sre.SRE_Match object; span=(4, 7), match='r4n'>
# \W : opposite to \w
print(re.search(r"r\Wn", "r\nn r4n"))          # <_sre.SRE_Match object; span=(0, 3), match='r\nn'>
# \b : empty string (only at the start or end of the word)
print(re.search(r"\bruns\b", "dog runs to cat"))    # <_sre.SRE_Match object; span=(4, 8), match='runs'>
# \B : empty string (but not at the start or end of a word)
print(re.search(r"\B runs \B", "dog   runs  to cat"))  # <_sre.SRE_Match object; span=(8, 14), match=' runs '>
# \\ : match \
print(re.search(r"runs\\", "runs\ to me"))     # <_sre.SRE_Match object; span=(0, 5), match='runs\\'>
# . : match anything (except \n)
print(re.search(r"r.n", "r[ns to me"))         # <_sre.SRE_Match object; span=(0, 3), match='r[n'>
# ^ : match line beginning
print(re.search(r"^dog", "dog runs to cat"))   # <_sre.SRE_Match object; span=(0, 3), match='dog'>
# $ : match line ending
print(re.search(r"cat$", "dog runs to cat"))   # <_sre.SRE_Match object; span=(12, 15), match='cat'>
# ? : may or may not occur
print(re.search(r"Mon(day)?", "Monday"))       # <_sre.SRE_Match object; span=(0, 6), match='Monday'>
print(re.search(r"Mon(day)?", "Mon"))          # <_sre.SRE_Match object; span=(0, 3), match='Mon'>

注：对于多行匹配首行，可以使用flags= re.M

import re

string = """
dog runs to cat.
I run to dog.
"""
print(re.search(r"^I", string))              
print(re.search(r"^I", string, flags=re.M))   
#输出如下 
#None
#<re.Match object; span=(18, 19), match='I'>

2.重复匹配

• * : 重复零次或多次
• + : 重复一次或多次
• {n, m} : 重复 n 至 m 次

# * : occur 0 or more times
print(re.search(r"ab*", "a"))             
print(re.search(r"ab*", "abbbbb"))       

# + : occur 1 or more times
print(re.search(r"ab+", "a"))             
print(re.search(r"ab+", "abbbbb"))       

# {n, m} : occur n to m times
print(re.search(r"ab{2,10}", "a"))       
print(re.search(r"ab{2,10}", "abbbbb"))  

#输出如下
#<re.Match object; span=(0, 1), match='a'>
#<re.Match object; span=(0, 6), match='abbbbb'>
#None
#<re.Match object; span=(0, 6), match='abbbbb'>
#None
#<re.Match object; span=(0, 6), match='abbbbb'>

注：贪婪模式与非贪婪模式

正则表达式通常用于在文本中查找匹配的字符串。Python里数量词默认是贪婪的（在少数语言里也可能是默认非贪婪），总是尝试匹配尽可能多的字符；非贪婪的则相反，总是尝试匹配尽可能少的字符。例如：正则表达式"ab*"如果用于查找"abbbc"，将找到"abbb"。而如果使用非贪婪的数量词"ab*?"，将找到"a"。

3.对匹配到的内容分组（）

import re
import datetime

apoint  = datetime.datetime.now()
print(apoint)
match = re.search(r"(\d*-\d*-\d*)\s(.*\.)",str(apoint))
print(match.group())
print(match.group(1))
print(match.group(2))

#输入如下
#2020-04-15 22:23:11.923944
#2020-04-15 22:23:11.
#2020-04-15
#22:23:11.

当组很多时，光用数字很难定位到想要的信息，可以给匹配的（）添加label：需要在括号的开头写上？P<label>

apoint  = datetime.datetime.now()
print(apoint)
match = re.search(r"(?P<date>\d*-\d*-\d*)\s(?P<time>.*\.)",str(apoint))
print(match.group())
print(match.group("date"))
print(match.group("time"))

#输出如下
#2020-04-15 22:26:51.309988
#2020-04-15 22:26:51.
#2020-04-15
#22:26:51.

4.re.search() & re.findall()

#re.search & re.findall

string = "run ran rbn"
print(re.search(r'r[ua]n',string))
print(re.search(r'r(u|a)n',string))

print(re.findall(r'r[ua]n',string))
print(re.findall(r'(run|ran)',string))


#输出如下
#<re.Match object; span=(0, 3), match='run'>
#<re.Match object; span=(0, 3), match='run'>
#['run', 'ran']
#['run', 'ran']

5.re.sub()用法

#replace re.sub
#通过正则表达匹配上一些字符然后替代
print(re.sub(r'r[ua]ns','catches','dog runs to cat '))

#输出如下
#dog catches to cat 

6.re.split()用法

其中可以指定多种分割符

a = "A;B,C.D:E;F"
print(re.split(r'[;,\.:]',a))
#输出如下
#['A', 'B', 'C', 'D', 'E', 'F']

7.re.compile()用法

可以使用compile来对正则重复使用

a_re = re.compile(r'r[u,a]n')
print(a_re.findall("run r,n ran rbn "))
#输出如下
#['run', 'r,n', 'ran']

 

参考：python 正则表达式指南

以上，记录本人学习过程。