【自然语言处理基础技能（NLP）】python正则表达式

正则表达式规则表：

正则表达式测试连接 ：http://regexr.com/

进阶练习：https://alf.nu/RegexGolf

python 【re模块】

 

s = 'ABC\\-001' # Python的字符串
# 对应的正则表达式字符串变成：
# 'ABC\-001'

#建议使用Python的r前缀，就不用考虑转义的问题了：

s = r'ABC\-001' # Python的字符串
# 对应的正则表达式字符串不变：
# 'ABC\-001'

#先看看如何判断正则表达式是否匹配：

>>> import re
>>> re.match(r'^\d{3}\-\d{3,8}$', '010-12345')
<_sre.SRE_Match object; span=(0, 9), match='010-12345'>
>>> re.match(r'^\d{3}\-\d{3,8}$', '010 12345')
>>>

# match()方法判断是否匹配，如果匹配成功，返回一个Match对象，否则返回None。常见的判断方法就是：

test = '用户输入的字符串'
if re.match(r'正则表达式', test):
    print('ok')
else:
    print('failed')

import re
#^d{3}表示前三位为三个数字，^表示的是指前三位，超过三位会报错
m=re.match(r'^\d{3}-\d{3,8}$', '111-123456')
print(m.string)
#用正则表达式切分字符串比用固定的字符更灵活，请看正常的切分代码：
print('a b   c'.split(' '))

#无法识别连续的空格，用正则表达式试试：
print(re.split(r'\s+', 'a b   c'))
print(re.split(r'\S+', 'a b   c'))

#无论多少个空格都可以正常分割。加入,试试：

print(re.split(r'[\s\,]+', 'a,b, c  d'))

#再加入;试试：

print(re.split(r'[\s\,\;]+', 'a,b;; c  d'))

#除了简单地判断是否匹配之外，正则表达式还有提取子串的强大功能。用()表示的就是要提取的分组（Group）。比如：

#^(\d{3})-(\d{3,8})$分别定义了两个组，可以直接从匹配的字符串中提取出区号和本地号码：

m1 = re.match(r'^(\d{3})-(\d{3,8})$', '010-12345')

print(m1.group(0))
print(m1.group(1))
print(m1.group(2))

t='09:09:09'
#以下写法识别时间错误，不能真缺识别非时间字符串
m=re.match(r'^([0-9][0-9])\:([0-9][0-9])\:([0-9][0-9])',t)
print(m.groups())
#以下为识别时间的正确写法：
# | 优先匹配左侧的表达式，一旦左侧的表达式匹配成功，则忽略右侧的其它表达式匹配
m2 = re.match(r'^(0[0-9]|1[0-9]|2[0-3]|[0-9])\:(0[0-9]|1[0-9]|2[0-9]|3[0-9]|4[0-9]|5[0-9]|[0-9])'
              r'\:(0[0-9]|1[0-9]|2[0-9]|3[0-9]|4[0-9]|5[0-9]|[0-9])$', t)
print(m2.groups())

#正则匹配是贪婪匹配，会尽可能多的匹配
print(re.match(r'^(\d+)(0*)$', '102300').groups())

#贪婪匹配
#最后需要特别指出的是，正则匹配默认是贪婪匹配，也就是匹配尽可能多的字符。举例如下，匹配出数字后面的0：

print(re.match(r'^(\d+)(0*)$', '102300').groups())

#由于\d+采用贪婪匹配，直接把后面的0全部匹配了，结果0*只能匹配空字符串了。
#必须让\d+采用非贪婪匹配（也就是尽可能少匹配），才能把后面的0匹配出来，加个?就可以让\d+采用非贪婪匹配：
#注意：这里不能省去d后面的＋号，不然会报错
print( re.match(r'^(\d+?)(0*)$', '102300').groups())

#重复利用同一正则表达式时，节省时间方法：一次编译，多次使用。
#当我们在Python中使用正则表达式时，re模块内部会干两件事情：编译正则表达式，如果正则表达式的字符串本身不合法，会报错；
#用编译后的正则表达式去匹配字符串。如果一个正则表达式要重复使用几千次，出于效率的考虑，我们可以预编译该正则表达式，接
# 下来重复使用时就不需要编译这个步骤了，直接匹配：

import re
# 编译:
re_telephone = re.compile(r'^(\d{3})-(\d{3,8})$')
# 使用：
print(re_telephone.match('010-12345').groups()) 
print(re_telephone.match('010-8086').groups())

结果显示：

 

 

 

使用re的一般步骤是

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

# encoding: UTF-8
import re
 
# 将正则表达式编译成Pattern对象
pattern = re.compile(r'hello.*\!')
 
# 使用Pattern匹配文本，获得匹配结果，无法匹配时将返回None
match = pattern.match('hello, hanxiaoyang! How are you?')
 
if match:
    # 使用Match获得分组信息
    print match.group()

hello, hanxiaoyang!

 

re.compile(strPattern[, flag]):

• re.I(re.IGNORECASE): 忽略大小写（括号内是完整写法，下同）
• re.M(MULTILINE): 多行模式，改变'^'和'$'的行为（参见上图）
• re.S(DOTALL): 点任意匹配模式，改变'.'的行为
• re.L(LOCALE): 使预定字符类 \w \W \b \B \s \S 取决于当前区域设定
• re.U(UNICODE): 使预定字符类 \w \W \b \B \s \S \d \D 取决于unicode定义的字符属性
• re.X(VERBOSE): 详细模式。这个模式下正则表达式可以是多行，忽略空白字符，并可以加入注释。以下两个正则表达式是等价的：

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