python之正则表达式

最新推荐文章于 2023-10-30 09:53:17 发布

timothy_lau

最新推荐文章于 2023-10-30 09:53:17 发布

阅读量346

点赞数 1

分类专栏： python

本文链接：https://blog.youkuaiyun.com/timothy_lau/article/details/50866703

版权

python 专栏收录该内容

8 篇文章

订阅专栏

主要介绍核心函数和元字符

1. 四个核心的函数

1.1 re.compile

Compile a regular expression pattern into a regular expression object, which can be used for matching using its match() and search() methods, but using re.compile() and saving the resulting regular expression object for reuse is more efficient when the expression will be used several times in a single program.

通过compile编译的对象, 处理起来速度会快很多, 并且在重复利用的时候, 有很大的优势
The sequence：
prog = re.compile(pattern)
result = prog.match(string)
is equivalent to：
result = re.match(pattern, string)

1.2 re.findall

re.findall可以获取字符串中所有匹配的字符串。它和match/rearch的区别在于：前者会匹配整个字符串, 而后者只要一个匹配上就直接结束, 放弃后面的匹配。

其中findall的定义中有如下一段话：

If one or more capturing groups are present in the pattern, return a list of groups; this will be a list of tuples if the pattern has more than one group.

下面举例来解释这段话的含义：

<span style="font-family:Microsoft YaHei;font-size:12px;"># coding:utf-8
import re
s = "the JD Group is the fourth IT company in china"
reObj1 = re.compile('((\w+)\s+\w+)') 
print(reObj1.findall(s))
reObj2 = re.compile('(\w+)\s+\w+')
print(reObj2.findall(s))
reObj3 = re.compile('\w+\s+\w+')
print(reObj3.findall(s))</span>

结果如下：

<span style="font-family:Microsoft YaHei;font-size:12px;">[('the JD', 'the'), ('Group is', 'Group'), ('the fourth', 'the'), ('IT company', 'IT'), ('in china', 'in')]
['the', 'Group', 'the', 'IT', 'in']
['the JD', 'Group is', 'the fourth', 'IT company', 'in china']</span>

解释如下：

文中的group代表一对括号()，如果pattern中有多个group，那么这些这些group就会组成tuple；然后这些tuple（也就是groups）组成了list。

1.当给出的正则表达式中带有多个括号时，列表的元素为多个字符串组成的tuple，tuple中字符串个数与括号对数相同，字符串内容与每个括号内的正则表达式相对应，并且排放顺序是按括号出现的顺序。

2.当给出的正则表达式中带有一个括号时，列表的元素为字符串，此字符串的内容与括号中的正则表达式相对应（不是整个正则表达式的匹配内容）。相当于进行了两次正则，首先(\w+)\s+\w+得到['the JD', 'Group is', 'the fourth', 'IT company', 'in china'],然后再进行\w+，得到['the', 'Group', 'the', 'IT', 'in']

3.当给出的正则表达式中不带括号时，列表的元素为字符串，此字符串为整个正则表达式匹配的内容。

1.3 re.match

re.match 尝试从字符串的开始匹配一个模式，如：下面的例子匹配第一个单词。

<span style="font-family:Microsoft YaHei;font-size:12px;"># coding:utf-8
import re
text = "JGood is a handsome boy, he is cool, clever, and so on..."
m = re.match(r"(\w+)\s", text)  
if m:  
    print(m.group(0) + ":" +  m.group(1))
else:  
    print('not match')</span>

结果：

<span style="font-family:Microsoft YaHei;font-size:12px;">JGood :JGood</span>

备注：这里面的r 表示pattern中的字符不用转义

1.4 re.search

re.search函数会在字符串内查找模式匹配,只到找到第一个匹配然后返回，如果字符串没有匹配，则返回None。

<span style="font-family:Microsoft YaHei;font-size:12px;"># coding:utf-8
import re
text = "JGood is a handsome boy, he is cool, clever, and so on..."
m = re.search(r"\s(\w+)\s", text)  
if m:  
    print(m.group(0) + ":" +  m.group(1))
else:  
    print('not match')</span>

结果：

<span style="font-family:Microsoft YaHei;font-size:12px;">is :is</span>

re.match与re.search的区别：re.match只匹配字符串的开始，如果字符串开始不符合正则表达式，则匹配失败，函数返回None；而re.search匹配整个字符串，直到找到一个匹配。
扩展函数：group（常用于match和search中）用来提出分组截获的字符串, ()用来分组：

返回匹配到的一个或者多个子组。如果是一个参数，那么结果就是一个字符串，如果是多个参数，那么结果就是一个参数一个item的元组。

group1的默认值为0(将返回所有的匹配值).如果groupN参数为0，相对应的返回值就是全部匹配的字符串，如果group1的值是[1…99]范围之内的,那么将匹配对应括号组的字符串。

如果组号是负的或者比pattern中定义的组号大，那么将抛出IndexError异常(IndexError: no such group)。如果pattern没有匹配到，但是group匹配到了，那么group的值也为None。

举例：

# coding:utf-8

<span style="font-family:Microsoft YaHei;font-size:12px;">import re
a = "123abc456"
pattern = "([0-9]*)([a-z]*)([0-9]*)"
print(re.search(pattern, a).group(0))   
print(re.search(pattern, a).group(1))   
print(re.search(pattern, a).group(2))  
print(re.search(pattern, a).group(3))</span>

结果：

123abc456

<span style="font-family:Microsoft YaHei;font-size:12px;">123
abc
456</span>

2. “\字符” 的含义

\d 匹配任何十进制数；它相当于类 [0-9]。

\D 匹配任何非数字字符；它相当于类 [^0-9]。

\s 匹配任何空白字符；它相当于类 [ fv]。
\S 匹配任何非空白字符；它相当于类 [^ fv]。
\w 匹配任何字母数字字符；它相当于类 [a-zA-Z0-9_]。
\W 匹配任何非字母数字字符；它相当于类 [^a-zA-Z0-9_]。

3. re的元字符

3.1 元字符(.)

元字符"."在默认模式下，匹配除换行符外
的所有字符。(Matches any character except a newline.)
在DOTALL模式下，匹配所有字符，包括换行符。

<span style="font-family:Microsoft YaHei;font-size:12px;">>>> import re
>>> print(re.match(".", "\n"))
None
>>> print(re.match(".","\n",re.DOTALL).group())
\n</span>

3.2 元字符(^)

最常用的用法：Matches the start of the string.

>>> import re

<span style="font-family:Microsoft YaHei;font-size:12px;">>>> print(re.search("ab+","asdfabbbb").group())
abbbb</span>

上例不能用re.match,因为match匹配字符串的开始，我们无法验证元字符"^"是否代表字符串的开始位置。

>>> import re

<span style="font-family:Microsoft YaHei;font-size:12px;">>>> print(re.match("ab+","asdfabbbb"))
None</span>

当和[]一起时表示求补集：A "^" as the first character indicates a complementing set.

<span style="font-family:Microsoft YaHei;font-size:12px;">>>> import re
>>> print(re.search("[^abc]","abcd").group())
d</span>

如果"^"在[ ]中不是首字符，那么那就是一个普通字符

<span style="font-family:Microsoft YaHei;font-size:12px;">>>> import re
>>> print(re.search("[abc^]","^").group())
^</span>

官方文档http://docs.python.org/library/re.html有关元字符”^”有这么一句话，Matches the start of the string, and in MULTILINE mode also matches immediately after each newline. 我理解的是”^”匹配字符串的开始，在MULTILINE模式下，也匹配换行符之后。
验证：

<span style="font-family:Microsoft YaHei;font-size:12px;">>>> import re
>>> print(re.findall("^a\w+","abcdfa\na1b2c3",re.MULTILINE))
['abcdfa', 'a1b2c3']</span>

3.3 元字符($)

匹配字符串的结尾或者字符串结尾的换行之前。（在MULTILINE模式下，"$"也匹配换行之前）

正则表达式"foo\w*"既匹配"foo"又匹配"foobar",而"foo$"仅仅匹配"foo".

<span style="font-family:Microsoft YaHei;font-size:12px;">>>> import re
>>> print(re.findall("foo.$","foo1\nfoo2\n"))
['foo2']
>>> print(re.findall("foo.$","foo1\nfoo2\n",re.MULTILINE))
['foo1', 'foo2']</span>

看来re.MULTILINE对$的影响还是蛮大的。
3.4 元字符(*)

Matches 0 or more (greedy) repetitions of the preceding RE. Greedy means that it will match as many repetitions as possible.
3.5 元字符(+)

Matches 1 or more (greedy) repetitions of the preceding RE.
3.6 元字符(?)

Matches 0 or 1 (greedy) of the preceding RE.

3.7 元字符({})
3.7.1
{m},用来表示前面正则表达式的m次copy，如"a{5}"，表示匹配5个”a”,即"aaaaa"

{m.n}用来表示前面正则表达式的m到n次copy,尝试匹配尽可能多的copy。

{m,n}? (Non-greedy version)用来表示前面正则表达式的m到n次copy，尝试匹配尽可能少的copy

<span style="font-family:Microsoft YaHei;font-size:12px;">>>> import re
>>> print(re.findall("a{5}","aaaaaaaaaa"))
['aaaaa', 'aaaaa']
>>> print(re.findall("a{2,4}","aaaaaaaa"))
['aaaa', 'aaaa']
>>> print(re.findall("a{2,4}?","aaaaaaaa"))
['aa', 'aa', 'aa', 'aa']</span>

3.7.2
有时候{}后面跟format的话，表示占位符，占位符中的内容，用format中的内容来填充，如下：

<span style="font-family:Microsoft YaHei;font-size:12px;">#获取时间点所在周的第一天	
def getWeekFirst(sep = '-', ws=0):
    p_dateTime = setDay(-2)
    return(p_dateTime - timedelta(days = (p_dateTime.weekday() + ws))).strftime('%Y{0}%m{0}%d'.format(sep)) 
#这里的{0}都被赋值为sep, 当然了，如果不嫌麻烦，可以'%Y{0}%m{1}%d'.format(sep, sep)</span>

3.8 元字符([ ])

它用来指定一个character class。所谓character classes就是你想要匹配的字符(character)的集合.
字符(character)可以单个的列出，也可以通过"-"来分隔两个字符来表示一个范围。
例如，[abc]匹配a，b或者c当中任意一个字符，[abc]也可以用字符区间来表示[a-c].如果想要匹配单个大写字母，你可以用 [A-Z]。
元字符(metacharacters)在character class里面不起作用，如[akm$]将匹配"a","k","m","$"中的任意一个字符。
在这里元字符(metacharacter)"$"就是一个普通字符。
3.9 元字符(|)

表示"或"，如A|B，其中A，B为正则表达式，表示匹配A或者B
3.10 元字符("( )")

用来表示一个group的开始和结束。比较常用的有(REs),(?P<name>REs),这是无名称的组和有名称的group，有名称的group，可以通过matchObject.group(name)获取匹配的group，而无名称的group可以通过从1开始的group序号来获取匹配的组，如matchObject.group(1)
3.11 元字符(\)

元字符backslash。做为 Python 中的字符串字母，反斜杠后面可以加不同的字符以表示不同特殊意义。
它也可以用于取消所有的元字符，这样你就可以在模式中匹配它们了。
例如，如果你需要匹配字符 "[" 或 "\"，你可以在它们之前用反斜杠来取消它们的特殊意义： \[ 或 \\