《自然语言处理》- Python正则表达式

2021-09-11 17:34:41 阅读：170 来源： 互联网

标签：匹配 string re Python pattern 正则表达式 Pattern print 自然语言

1. Python 正则表达式

1.1 正则表达式语法

1.2 正则表达式工具

2. Python案例

Re 模块
使用re的一般步骤是
1. 将正则表达式的字符串形式编译为 Pattern 实例
2. 使用 Pattern 实例处理文本并获得匹配结果（一个 Match 实例）
3. 使用 Match 实例获得信息，进行其他的操作。

# encoding: UTF-8
import re

rule = r'hello.*\!' # 正则表达式规则 : 匹配 hello 开头, ! 结尾的字符串

# 将正则表达式编译成 Pattern 对象
pattern = re.compile(rule)

# 使用Pattern匹配文本，获得匹配结果，无法匹配时将返回None
match = pattern.match('hello, hanxiaoyang! How are you?')

if match:
    # 使用Match获得分组信息
    print(match.group())

hello, hanxiaoyang! How are you?

2.1 re.compile

re.compile(strPattern[, flag]):
这个方法是 Pattern 类的工厂方法，用于将字符串形式的正则表达式编译为 Pattern 对象。
第二个参数 flag 是匹配模式，取值可以使用按位或运算符’|'表示同时生效，比如 re.I | re.M。
也可以在 regex 字符串中指定模式，比如 re.compile(‘pattern’, re.I | re.M) 等价于 re.compile(’(?im)pattern’)
flag 可选值有:
1. re.I(re.IGNORECASE): 忽略大小写（括号内是完整写法，下同）
2. re.M(MULTILINE): 多行模式，改变’^‘和’$'的行为（参见上图）
3. re.S(DOTALL): 点任意匹配模式，改变’.'的行为
4. re.L(LOCALE): 使预定字符类 \w \W \b \B \s \S 取决于当前区域设定
5. re.U(UNICODE): 使预定字符类 \w \W \b \B \s \S \d \D 取决于unicode定义的字符属性
6. re.X(VERBOSE): 详细模式。这个模式下正则表达式可以是多行，忽略空白字符，并可以加入注释。以下两个正则表达式是等价的：

regex_1 = re.compile(r"""\d +  # 数字部分
                         \.    # 小数点部分
                         \d *  # 小数的数字部分""", re.X)
regex_2 = re.compile(r"\d+\.\d*")
regex_1, regex_2

(re.compile(r'\d +  # 数字部分\n                         \.    # 小数点部分\n                         \d *  # 小数的数字部分',
 re.UNICODE|re.VERBOSE),
 re.compile(r'\d+\.\d*', re.UNICODE))

2.2 Match

Match对象是一次匹配的结果，包含了很多关于此次匹配的信息，可以使用Match提供的可读属性或方法来获取这些信息。
match属性：
1. string: 匹配时使用的文本。
2. re: 匹配时使用的Pattern对象。
3. pos: 文本中正则表达式开始搜索的索引。值与Pattern.match()和Pattern.seach()方法的同名参数相同。
4. endpos: 文本中正则表达式结束搜索的索引。值与Pattern.match()和Pattern.seach()方法的同名参数相同。
5. lastindex: 最后一个被捕获的分组在文本中的索引。如果没有被捕获的分组，将为None。
6. lastgroup: 最后一个被捕获的分组的别名。如果这个分组没有别名或者没有被捕获的分组，将为None。
方法：
1. group([group1, …]):
  获得一个或多个分组截获的字符串；指定多个参数时将以元组形式返回。group1可以使用编号也可以使用别名；编号0代表整个匹配的子串；
  不填写参数时，返回group(0)；没有截获字符串的组返回None；截获了多次的组返回最后一次截获的子串。
2. groups([default]):
  以元组形式返回全部分组截获的字符串。相当于调用group(1,2,…last)。default表示没有截获字符串的组以这个值替代，默认为None。
3. groupdict([default]):
  返回以有别名的组的别名为键、以该组截获的子串为值的字典，没有别名的组不包含在内。default含义同上。
4. start([group]):
  返回指定的组截获的子串在string中的起始索引（子串第一个字符的索引）。group默认值为0。
5. end([group]):
  返回指定的组截获的子串在string中的结束索引（子串最后一个字符的索引+1）。group默认值为0。
6. span([group]):
  返回(start(group), end(group))。
7. expand(template):
  将匹配到的分组代入template中然后返回。template中可以使用\id或\g、\g引用分组，但不能使用编号0。\id与\g是等价的；但\10将被认为是第10个分组，如果你想表达\1之后是字符’0’，只能使用\g<1>0。

import re

# \w : 表示单词字符 : [a-z0-9]
rule = '(\w+) (\w+) (?P<sign>.*)'

m = re.match(rule, 'hello ni hao ya!')

print("匹配时使用的文本 : ", m.string)
print("匹配时使用的Pattern对象 : ", m.re)
print("文本中正则表达式开始搜索的索引 : ", m.pos)
print("文本中正则表达式结束搜索的索引 : ", m.endpos)
print("最后一个被捕获的分组在文本中的索引 : ", m.lastindex)
print("最后一个被捕获的分组的别名 : ", m.lastgroup)

print("m.group(1, 2) : ", m.group(1, 2))
print("m.groups() : ", m.groups())
print("m.groupdict() : ", m.groupdict())
print("m.start(2) : ", m.start(2))
print("m.end(2) : ", m.end(2))
print("m.span(2) : ", m.span(2))
print(m.expand(r'\2 \1 \3'))

匹配时使用的文本 :  hello ni hao ya!
匹配时使用的Pattern对象 :  re.compile('(\\w+) (\\w+) (?P<sign>.*)')
文本中正则表达式开始搜索的索引 :  0
文本中正则表达式结束搜索的索引 :  16
最后一个被捕获的分组在文本中的索引 :  3
最后一个被捕获的分组的别名 :  sign
m.group(1, 2) :  ('hello', 'ni')
m.groups() :  ('hello', 'ni', 'hao ya!')
m.groupdict() :  {'sign': 'hao ya!'}
m.start(2) :  6
m.end(2) :  8
m.span(2) :  (6, 8)
ni hello hao ya!

2.3 Pattern

Pattern 对象是一个编译好的正则表达式，通过 Pattern 提供的一系列方法可以对文本进行匹配查找。
Pattern 不能直接实例化，必须使用 re.compile() 进行构造。
Pattern 提供了几个可读属性用于获取表达式的相关信息:
1. pattern: 编译时用的表达式字符串。
2. flags: 编译时用的匹配模式。数字形式。
3. groups: 表达式中分组的数量。
4. groupindex: 以表达式中有别名的组的别名为键、以该组对应的编号为值的字典，没有别名的组不包含在内。

import re

rule = '(\w+) (\w+)(?P<sign>.*)' # r'' 是为了防止字符转义
p = re.compile(rule, re.DOTALL) # re.S(DOTALL): 点任意匹配模式，改变'.'的行为

print("编译时用的表达式字符串: " , p.pattern)
print("编译时用的匹配模式。数字形式: " , p.flags)
print("表达式中分组的数量: " , p.groups)
print("p.groups: " , p.groupindex)

编译时用的表达式字符串:  (\w+) (\w+)(?P<sign>.*)
编译时用的匹配模式。数字形式:  48
表达式中分组的数量:  3
p.groups:  {'sign': 3}

2.4 使用Pattern

match(string[, pos[, endpos]]) | re.match(pattern, string[, flags]):
这个方法将从 string 的 pos 下标处起尝试匹配 pattern:
1. 如果 pattern 结束时仍可匹配，则返回一个Match对象
2. 如果匹配过程中 pattern 无法匹配，或者匹配未结束就已到达 endpos，则返回 None。
3. pos 和 endpos 的默认值分别为 0 和 len(string)。
4. 注意：这个方法并不是完全匹配。当 pattern 结束时若 string 还有剩余字符，仍然视为成功。想要完全匹配，可以在表达式末尾加上边界匹配符’$’。
search(string[, pos[, endpos]]) | re.search(pattern, string[, flags]):
1. 这个方法从 string 的 pos 下标处起尝试匹配 pattern
2. 如果 pattern 结束时仍可匹配，则返回一个 Match 对象
3. 若无法匹配，则将 pos 加1后重新尝试匹配，直到 pos=endpos 时仍无法匹配则返回 None。
4. pos 和 endpos 的默认值分别为 0 和 len(string))

import re

# 将正则表达式编译成 Pattern 对象
rule = r'W.*i'
pattern = re.compile(rule) # 匹配规则以 W 开头, i结尾, 中间可以是任意字符

# 使用search()查找匹配的子串，不存在能匹配的子串时将返回None
# 这个例子中使用match()无法成功匹配
text = 'Hello, Wangtianci!'
match = pattern.search(text)
if match:
    # 使用Match获得分组信息
    print(match.group())

Wangtianci

split(string[, maxsplit]) | re.split(pattern, string[, maxsplit]):
1. 按照能够匹配的子串将string分割后返回列表。
2. maxsplit用于指定最大分割次数，不指定将全部分割。

import re

rule = r'\d+' # 表示 \d : 0 ~ 9 == [0-9]
p = re.compile(rule)
print(p.split('one1two2three3four4'))

['one', 'two', 'three', 'four', '']

findall(string[, pos[, endpos]]) | re.findall(pattern, string[, flags]):
1. 搜索string，以列表形式返回全部能匹配的子串。

import re

rule = r'\d+' # 表示 \d : 0 ~ 9 == [0-9]
p = re.compile(rule)
print(p.findall('one1two2three3four4'))

['1', '2', '3', '4']

finditer(string[, pos[, endpos]]) | re.finditer(pattern, string[, flags]):
1. 搜索string，返回一个顺序访问每一个匹配结果（Match对象）的迭代器。

import re

rule = r'[a-z]+' # 匹配字母的字符串
text = 'aaa1bbb2ccc3ddd4'
p = re.compile(rule)
for m in p.finditer(text):
    print(m.group())

aaa
bbb
ccc
ddd

sub(repl, string[, count]) | re.sub(pattern, repl, string[, count]):
1. 使用repl替换string中每一个匹配的子串后返回替换后的字符串。
2. 当repl是一个字符串时，可以使用\id或\g、\g引用分组，但不能使用编号0。
3. 当repl是一个方法时，这个方法应当只接受一个参数（Match对象），并返回一个字符串用于替换（返回的字符串中不能再引用分组）。
  count用于指定最多替换次数，不指定时全部替换。

rule = r'\d+' # 匹配字母的字符串
text = 'aaa1bbb2ccc3ddd'
p = re.compile(rule)

# repl : 字符串
print(p.sub(',', text)) # 替换掉匹配的字符

# repl : 方法
def func(m):
    # m  : <re.Match object; span=(3, 4), match='1'>
    print(m)
    # return m.group(0).title() + ' ' + m.group(1).title()
    return ','

print(p.sub(func, text))

aaa,bbb,ccc,ddd
<re.Match object; span=(3, 4), match='1'>
<re.Match object; span=(7, 8), match='2'>
<re.Match object; span=(11, 12), match='3'>
aaa,bbb,ccc,ddd

subn(repl, string[, count]) |re.sub(pattern, repl, string[, count]):
1. 返回 (sub(repl, string[, count]), 替换次数)。

rule = r'\d+' # 匹配字母的字符串
text = 'aaa1bbb2ccc3ddd'
p = re.compile(rule)

# repl : 字符串
print(p.subn(',', text)) # 返回替换次数

('aaa,bbb,ccc,ddd', 3)

标签：匹配,string,re,Python,pattern,正则表达式,Pattern,print,自然语言
来源： https://blog.csdn.net/weixin_40040107/article/details/120240588

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

ICode9