正则表达式快速入门二 ：python re module 常用API介绍

python regex module re 使用

reference regex module in python

import re

re.search

re.search(regex, subject， regex_matching_mode): apply a regex pettern to a subject string(with a specified searching mode)

searching mode: re.I(re.IGNORECASE) , re.S(re.DOTALL), re.M(re.MULTLINE) 可以使用 | 来使用多种mode e.g. re.I | re.S 。 re.L(re.LOCALE) re.U(re.UNICODE): 主要用于修改\w 对应word_characters 的范围

return None if matching attempt fails and a Match object otherwise

因为None 与False 等价 所以可以被用在 if statement

其他类似的function(不支持 regex matching flags)

re.match(regex, subject): re.search 遍历整个字符串来进行匹配，而re.match 只在字符串的开头寻找匹配 re.match("regex", subject) is equal to re.search("\Aregex", subject)

re.fullmatch(regex, subject): 只有在 subject与regex完全匹配时，return Match object, otherwise None （which is equal to re.search("\Aregex\Z", subject)）

re.findall(regex, subject: This will return an array of all non-overlapping regex matches in the string. 当 存在一个或者多个capturing groups时， return a array of tuple

re.finditer(regex, subject): return a iterator（more effcient than re.findall()） 返回一个由match object组成的迭代器

for m in re.finditer(regex, subject)

#  ordinary character
# r""  raw string literal
subject = "Hello_world_hello"
regex_1 = r"Hello"
regex_2 = r"World"

if re.search(regex_1, subject, flags=re.I):
    print('Match')
else:
    print('Not a match')

if re.search(regex_2, subject, flags=re.I):
    print('Match')
else:
    print('Not a match')

if re.search(regex_1, subject):
    print('Match')
else:
    print('Not a match')

if re.search(regex_2, subject):
    print('Match')
else:
    print('Not a match')

Match
Match
Match
Not a match

Match Details(关于匹配的细节)

re.search 和 re.match return a Match object ; re.finditer 生成一个迭代器用于遍历 Match object

Match object(using m to signify it) 包含关于match 的许多有用的信息

m.group(): returns the part of the string matched by the entire regular expression，即返回被整个正则表达式所匹配的部分

m.start(): returns the offset in the string of the start of the match ,返回匹配位置的偏移量

m.end():returns the offset of the character beyond the match, 返回match之后character的偏移量

m.span() : tuple(m.start(), m.end())

可以使用 m.start() 与 m.end() 进行切片， subject[m.start(): m.end()]

如果想要指定capturing_group 匹配的结果, e.g. m.group(group_number) m.group(group_name)

如果想要做搜索替换 而不调用 re.sub() 那么可以使用 m.expand(replacement) 去计算替换的结果

注意

re.search search throughout the string until find a match

re.match attempts the pattern at the very start of the string until find a match

re.findall and re.finditer will find all the matches

# the match details
m = re.search(regex_1, subject, flags=re.I)
print(f'regex   {regex_1}')
print(f'subject   {subject}')
print(f"m.group:   {m.group()}")
print(f"m.start:   {m.start()}")
print(f"m.end:   {m.end()}")
print(f"m.span:   {m.span()}")
print(subject[m.start():m.end()])

regex   Hello
subject   Hello_world_hello
m.group:   Hello
m.start:   0
m.end:   5
m.span:   (0, 5)
Hello

# finditer
for m in re.finditer(r'(?i)' + regex_1, subject):
    print(m.span())
    print(subject[m.start(): m.end()])

(0, 5)
Hello
(12, 17)
hello

# findall
print(re.findall(r'(?i)' + regex_1, subject))
print(type( re.findall(r'(?i)' + regex_1, subject) ))

['Hello', 'hello']
<class 'list'>

Strings , Backslashes and Regular Expressions

regex 使用 反斜杠进行转义特殊字符， 而python字符串中也使用反斜杠进行转义字符。 因此\\ 在正则表达式中为一个literal backslash 对应的python字符串 为 \\\\ 不便于阅读

因此采用 python 的 raw string 特性 r"\\" 对于字符串去转义， 以简化 正则表达式的书写

regex_non_raw = '\\\\'
regex_raw = r'\\'

literal_backblash = r'\abc'

if re.search(regex_non_raw, literal_backblash):
    print('Match')
else:
    print('not a Match')

if re.search(regex_raw, literal_backblash):
    print('Match')
else:
    print('not a Match')

Match
Match

Unicode

关于 Unicode notation \uFFFF

为了避免关于反斜杠是否应该被转义的困惑， 我们应该使用 raw Unicode string ur"\uFFFF\d"（当然前缀u并不必要）

print(u'\uEFFFa')

a

Search and Replace

查找替换的实现

re.sub(regex, replacement, subject): replacing all matches of regex in subject with replacement。

return the result of modified(the subject is not modified)

如果regex有 capturing groups, 可以使用 \g \number 来指定替换的group

result = re.sub(regex_1, 'world', subject, flags= re.I)
result_with_constrained_times = re.sub(regex_1, 'world', subject, count=1)

print(f'replace all match :   {result}')
print(f'replace match according to specified times :   {result_with_constrained_times}')

replace all match :   world_world_world
replace match according to specified times :   world_world_hello

Splitting Strings

re.split(regex, subject， control_the_number_of_splits): 根据 regex matches 将字符串进行切分

return a array of string(the matches is not included in the result but the capturing_groups is included in the result)

target = re.split(regex_1, subject, flags=re.I)
target_with_contrained_times = re.split(regex_1, subject, maxsplit=1, flags=re.I)

print(f"split_result_without_limit:    {target}")
print(f"split_result_with_limit:    {target_with_contrained_times}")

split_result_without_limit:    ['', '_world_', '']
split_result_with_limit:    ['', '_world_hello']

Regex Objects

如果想要多次使用同一个正则表达式， 那么需要将其编译为一个 regular expression object

re.compile(regex) or re.compile(regex, flags): flags switch the matching mode

return regular expression object(regex_object)

regex_object 可以使用re库的所有函数

e.g.

re.compile.search(subject) == re.search(regex, subject)

re_object = re.compile(regex_1, flags=re.I)

print(re_object.findall(subject))

['Hello', 'hello']

总结

以上就是python正则表达式module re 的常用接口以及其与正则表达式之间的关系

以上内容中缺少 grouping_and_capturing 这一部分，并没有展示在存在capturing group时上述函数接口的表现，仅仅介绍了相关内容

进一步进阶使用时，主要体现在提升正则表达式的复杂度上，在这个notebook中只展示了 使用literal_text 进行匹配的结果