Python正则表达式re库的初次使用入门

正则表达式常用操作符：

操作符	说明	实例
.	表示任何单个字符，不包括换行符
[]	字符集，对单个字符给出取值范围	[abc]表示a、b、c，[a-z]表示a到z单个字符
[^ ]	非字符集	[^abc]表示非a或b或c
*	前一个字符0次或无限次扩展	abc*表示ab、abc、abcc、abccc、……
+	前一个字符一次或无限次扩展	abc+表示abc、abcc、abccc、……
？	前一个字符0次或1次扩展	abc?表示ab、abc
|	左右表达式任意一个	abc|def表示abc、def
{m}	扩展前一个字符m次	ab{2}c表示abbc
{m,n}	扩展前一个字符m至n次（含n）	{ab{1,2}c表示abc、abbc
^	匹配字符串开头	^abc表示abc且在一个字符串的开头
$	匹配字符串结尾	abc$表示abc且在一个字符串的结尾
()	分组标记，内部只能有|操作符	(abc)表示abc，(abc
\d	数字
\w	单词字符，等价于[A-Za-z0-9]

import re

常用方法

re库常用方法：

函数	说明
re.search()	在一个字符串中搜索匹配正则表达式的第一个位置，返回match对象
re.match()	从一个字符串的开始位置起匹配正则表达式，返回match对象
re.findall()	搜索字符串，以列表类型返回全部能匹配的子串
re.split()	将字符串按照正则表达式匹配结果进行分割，返回列表类型
re.finditer()	搜索字符串，返回一个匹配结果的迭代类型，每个迭代元素是match对象
re.sub()	在一个字符串中替换所有匹配正则表达式的子串，返回替换后的字符串

flags：正则表达式使用时的控制标记

常用标记	说明
re.I re.IGNORECASE	忽略大小写，[A-Z]可以匹配小写字母
re.M re.MULTILINE	^操作符能够将给定的字符串每行都当作匹配开始
re.S re.DOTALL	.操作符能够匹配所有字符，包括换行符

• re.search(pattern, string, flags=0)

s = "abc 123 abc 456"
match = re.search("\d+", s)
print("match的类型：", type(match))
print("匹配的子串：", match.group(0))

    match的类型： <class 're.Match'>
    匹配的子串： 123

• re.match(pattern, string, flags=0)

s = "123 abc"
match = re.match("\d+", s)
print("match的类型：", type(match))
print("匹配的子串：", match.group(0))
print("----------------")

s = "abc 123 abc"
match = re.match("\d+", s)
print("match的类型：", type(match))
try:
    print("匹配的子串：", match.group(0))
except:
    pass

    match的类型： <class 're.Match'>
    匹配的子串： 123
    ----------------
    match的类型： <class 'NoneType'>

• re.findall(pattern, string, flags=0)

s = "abc 123 456 bcd 23 dsssa12"
match = re.findall("1\d+", s)  # 以1开头的数字
match

    ['123', '12']

• re.finditer(pattern, string, flags=0)

s = "abc 123 456 bcd 23 dsssa12"
match = re.finditer("1\d+", s)
while True:
    try:
        print(next(match).group(0))
    except:
        break

    123
    12

• re.split(pattern, string, maxsplit=0, flags=0)

maxsplit：最大分隔数，将剩余部分作为一个整体当作最后一个元素，默认的0表示最大分隔

s = "abc 123 456 bcd 23 dsssa12"
match1 = re.split("\d{2}", s)  #以连续的两个数字作为分隔条件
match2 = re.split("\d{2}", s, maxsplit=2)  #以连续的两个数字作为分隔条件
print(match1, match2)

    ['abc ', '3 ', '6 bcd ', ' dsssa', ''] ['abc ', '3 ', '6 bcd 23 dsssa12']

• re.sub(pattern, repl, string, count=0, flags=0)

repl：将匹配的子串换成该字符串

s = "abc 123 456 bcd 23 dsssa12"
s1 = re.sub("[0-9][^a-z]*", "**", s)
s2 = re.sub("[0-9][^a-z]*", "**", s, count=2)
print(s1, s2, sep='\n')

    abc **bcd **dsssa**
    abc **bcd **dsssa12

• re.compile(pattern, flags=0)

s = "abc 123 456 bcd 23 dsssa12"
pat = re.compile("\d+")

rst = pat.search(s)
print(rst.group(0))

rst = pat.findall(s)
print(rst)

    123
    ['123', '456', '23', '12']

match对象的属性和方法

s = "sdf 123 asd"
match = re.search("\d+", s)

print(match.string)  # 被匹配的文本
print(match.re)  # 匹配时使用的pattern对象
print(match.pos)  # 从该位置开始搜索的文本
print(match.endpos)  # 搜索文本的结束位置
print(match.group(0))  # 一般的正则表达式使用group(0)就可以获得匹配的字符串
print(match.start())  # 匹配的字符串在原字符串中的起始位置
print(match.end())  # 匹配的字符串在原字符串中的结束位置
print(match.span())  # 起始和结束位置的元组

    sdf 123 asd
    re.compile('\\d+')
    0
    11
    123
    4
    7
    (4, 7)

贪婪匹配和最小匹配

s = "PYANBNCNDN"
match = re.search("PY.*N", s)
print(match.group(0))

    PYANBNCNDN

对于代码中的模式串和字符串，正则匹配可以有"PYAN"、"PYANBN"、"PYANBNCN"、"PYANBNCNDN"些个匹配结果。

而上述代码说明re库默认是贪婪匹配，即输出最长的子串。

下面将贪婪模式改成最小模式:

操作符	说明
*?	将*扩展为最小匹配
+?	将+扩展为最小匹配
??	将?扩展为最小匹配
{m,n}?	将{m,n}扩展为最小匹配

当我们发现一个模式串中的每个操作符可匹配不同长度的子串时，我们都可以在该操作符的后面添加?来获得最小匹配。

match = re.search("PY.*?N", s)
print(match.group(0))

    PYAN