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
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 进行匹配的结果
标签：regex,python,module,re,Match,print,match,subject From： https://www.cnblogs.com/wclsn-blog/p/17031923.html