正则表达式简介和NLP中文本处理常用情形

目录

一、常用符号的解释

二、正则表达式中常用相关函数

1、re.match(pattern,string，flags)

2、re.fullmatch(pattern,string，flags)

3、re.search(pattern,string，flags)

4、re.split(pattern,string，flags)

5、re.sub(pattern,replace,string)

6、re.findall(pattern,string)

7、re.compile(pattern)

三、NLP中文本处理常用情形

1、电话号码匹配(包含座机号码和手机号码，不含合法性检测)

2、邮箱的匹配(不含合法性检测)

3、身份证号码匹配

4、整体性和非的综合性匹配

总结

---

正则表达式简介和NLP中文本处理常用情形

一、常用符号的解释

字符	描述
\	将下一个字符标记为一个特殊字符、或一个原义字符、或一个 向后引用、或一个八进制转义符。例如，'n' 匹配字符 "n"。'\n' 匹配一个换行符。序列 '\\' 匹配 "\" 而 "\(" 则匹配 "("。
^	匹配输入字符串的开始位置。如果设置了 RegExp 对象的 Multiline 属性，^ 也匹配 '\n' 或 '\r' 之后的位置。
$	匹配输入字符串的结束位置。如果设置了RegExp 对象的 Multiline 属性，$ 也匹配 '\n' 或 '\r' 之前的位置。
*	匹配前面的子表达式零次或多次。例如，zo* 能匹配 "z" 以及 "zoo"。* 等价于{0,}。
+	匹配前面的子表达式一次或多次。例如，'zo+' 能匹配 "zo" 以及 "zoo"，但不能匹配 "z"。+ 等价于 {1,}。
?	匹配前面的子表达式零次或一次。例如，"do(es)?" 可以匹配 "do" 或 "does" 中的"do" 。? 等价于 {0,1}。
{n}	n 是一个非负整数。匹配确定的 n 次。例如，'o{2}' 不能匹配 "Bob" 中的 'o'，但是能匹配 "food" 中的两个 o。
{n,}	n 是一个非负整数。至少匹配n 次。例如，'o{2,}' 不能匹配 "Bob" 中的 'o'，但能匹配 "foooood" 中的所有 o。'o{1,}' 等价于 'o+'。'o{0,}' 则等价于 'o*'。
{n,m}	m 和 n 均为非负整数，其中n <= m。最少匹配 n 次且最多匹配 m 次。例如，"o{1,3}" 将匹配 "fooooood" 中的前三个 o。'o{0,1}' 等价于 'o?'。请注意在逗号和两个数之间不能有空格。
?	当该字符紧跟在任何一个其他限制符 (*, +, ?, {n}, {n,}, {n,m}) 后面时，匹配模式是非贪婪的。非贪婪模式尽可能少的匹配所搜索的字符串，而默认的贪婪模式则尽可能多的匹配所搜索的字符串。例如，对于字符串 "oooo"，'o+?' 将匹配单个 "o"，而 'o+' 将匹配所有 'o'。
.	匹配除 "\n" 之外的任何单个字符。要匹配包括 '\n' 在内的任何字符，请使用象 '[.\n]' 的模式。
(pattern)	匹配 pattern 并获取这一匹配。所获取的匹配可以从产生的 Matches 集合得到，在VBScript 中使用 SubMatches 集合，在JScript 中则使用 0…0…9 属性。要匹配圆括号字符，请使用 '′或′′或′'。
(?:pattern)	匹配 pattern 但不获取匹配结果，也就是说这是一个非获取匹配，不进行存储供以后使用。这在使用 "或" 字符 (|) 来组合一个模式的各个部分是很有用。例如， 'industr(?:y|ies) 就是一个比 'industry|industries' 更简略的表达式。
(?=pattern)	正向预查，在任何匹配 pattern 的字符串开始处匹配查找字符串。这是一个非获取匹配，也就是说，该匹配不需要获取供以后使用。例如，'Windows (?=95|98|NT|2000)' 能匹配 "Windows 2000" 中的 "Windows" ，但不能匹配 "Windows 3.1" 中的 "Windows"。预查不消耗字符，也就是说，在一个匹配发生后，在最后一次匹配之后立即开始下一次匹配的搜索，而不是从包含预查的字符之后开始。
(?!pattern)	负向预查，在任何不匹配 pattern 的字符串开始处匹配查找字符串。这是一个非获取匹配，也就是说，该匹配不需要获取供以后使用。例如'Windows (?!95|98|NT|2000)' 能匹配 "Windows 3.1" 中的 "Windows"，但不能匹配 "Windows 2000" 中的 "Windows"。预查不消耗字符，也就是说，在一个匹配发生后，在最后一次匹配之后立即开始下一次匹配的搜索，而不是从包含预查的字符之后开始
x|y	匹配 x 或 y。例如，'z|food' 能匹配 "z" 或 "food"。'(z|f)ood' 则匹配 "zood" 或 "food"。
[xyz]	字符集合。匹配所包含的任意一个字符。例如， '[abc]' 可以匹配 "plain" 中的 'a'。
[^xyz]	负值字符集合。匹配未包含的任意字符。例如， '[^abc]' 可以匹配 "plain" 中的'p'。
[a-z]	字符范围。匹配指定范围内的任意字符。例如，'[a-z]' 可以匹配 'a' 到 'z' 范围内的任意小写字母字符。
[^a-z]	负值字符范围。匹配任何不在指定范围内的任意字符。例如，'[^a-z]' 可以匹配任何不在 'a' 到 'z' 范围内的任意字符。
\b	匹配一个单词边界，也就是指单词和空格间的位置。例如， 'er\b' 可以匹配"never" 中的 'er'，但不能匹配 "verb" 中的 'er'。
\B	匹配非单词边界。'er\B' 能匹配 "verb" 中的 'er'，但不能匹配 "never" 中的 'er'。
\cx	匹配由 x 指明的控制字符。例如， \cM 匹配一个 Control-M 或回车符。x 的值必须为 A-Z 或 a-z 之一。否则，将 c 视为一个原义的 'c' 字符。
\d	匹配一个数字字符。等价于 [0-9]。
\D	匹配一个非数字字符。等价于 [^0-9]。
\f	匹配一个换页符。等价于 \x0c 和 \cL。
\n	匹配一个换行符。等价于 \x0a 和 \cJ。
\r	匹配一个回车符。等价于 \x0d 和 \cM。
\s	匹配任何空白字符，包括空格、制表符、换页符等等。等价于 [ \f\n\r\t\v]。
\S	匹配任何非空白字符。等价于 [^ \f\n\r\t\v]。
\t	匹配一个制表符。等价于 \x09 和 \cI。
\v	匹配一个垂直制表符。等价于 \x0b 和 \cK。
\w	匹配包括下划线的任何单词字符。等价于'[A-Za-z0-9_]'。
\W	匹配任何非单词字符。等价于 '[^A-Za-z0-9_]'。
\xn	匹配 n，其中 n 为十六进制转义值。十六进制转义值必须为确定的两个数字长。例如，'\x41' 匹配 "A"。'\x041' 则等价于 '\x04' & "1"。正则表达式中可以使用 ASCII 编码。.
\num	匹配 num，其中 num 是一个正整数。对所获取的匹配的引用。例如，'(.)\1' 匹配两个连续的相同字符。
\n	标识一个八进制转义值或一个向后引用。如果 \n 之前至少 n 个获取的子表达式，则 n 为向后引用。否则，如果 n 为八进制数字 (0-7)，则 n 为一个八进制转义值。
\nm	标识一个八进制转义值或一个向后引用。如果 \nm 之前至少有 nm 个获得子表达式，则 nm 为向后引用。如果 \nm 之前至少有 n 个获取，则 n 为一个后跟文字 m 的向后引用。如果前面的条件都不满足，若 n 和 m 均为八进制数字 (0-7)，则 \nm 将匹配八进制转义值 nm。
\nml	如果 n 为八进制数字 (0-3)，且 m 和 l 均为八进制数字 (0-7)，则匹配八进制转义值 nml。
\un	匹配 n，其中 n 是一个用四个十六进制数字表示的 Unicode 字符。例如， \u00A9 匹配版权符号 (?)。

比较特殊的pattern

?=

exp1(?=exp2)：查找exp1后面是exp2的exp1

?!

exp1(?!exp2)：查找后面不是 exp2 的 exp1

?<=

(?<=exp2)exp1：查找 exp1前面是exp2的exp1

?<!

(?<!exp2)exp1：查找 exp1前面不是exp2的exp1

二、正则表达式中常用相关函数

这里主要是对正则表达式常用的函数进行一个演示

1、re.match(pattern,string，flags)

参数说明：pattern就是正则匹配模式，string匹配的源字符串，flags匹配模式int型，这个参数我一般用的少。

函数功能：从string的第一个字符起就开始和pattern开始匹配，完全满足了pattern就返回匹配结果，类型是个对象，需要取到具体的值就必须用其他API调用例如group()；反之返回none

代码举例：

    text = '55sdfdhjpythonNLPjkasdfasdad555151pythonNLP...'
    pattern = 'pythonNLP'
    result = re.match(pattern,text)
    print(result)

    text = 'pythonNLPpythonNLP'
    pattern = 'pythonNLP'
    result = re.match(pattern,text)
    print(result)
    print(result.group())

结果如下所示：

None
<re.Match object; span=(0, 9), match='pythonNLP'>
pythonNLP

2、re.fullmatch(pattern,string，flags)

匹配整个string源字符串和pattern是否匹配

3、re.search(pattern,string，flags)

功能和match类似，但是search的功能要更开放一些。从源字符串第一个字符开始匹配，只要没有匹配到pattern立马就从下一个字符继续开始匹配；直到匹配到一个完整的pattern的子字符串后结束，返回一个结果对象，可以用group()、span()等函数取得相应的结果。例如：

    text = 'kkpythonNLPpythonNLP'
    pattern = 'pythonNLP'
    result = re.search(pattern,text)
    print(result)
    print(result.group())

它的结果可以很清楚的看出就是pythonNLP，而且只有一个！结果：

<re.Match object; span=(2, 11), match='pythonNLP'>
pythonNLP

4、re.split(pattern,string，flags)

功能就是使用pattern定义的规则来对string字符串进行分隔，结果放在一个list返回。如：

    text = 'pythonNLP9Pytorch125tensorFlow'
    pattern = '[0-9]{1,3}'
    result = re.split(pattern,text)
    print(type(result))
    print(result)

例如现在用数字把几个英语词汇隔开了，现在要提取英语词汇。就可以用这种简单的正则匹配来做。结果如下：

<class 'list'>
['pythonNLP', 'Pytorch', 'tensorFlow']

5、re.sub(pattern,replace,string)

这个就是和string中的replace功能相似，只不过这里是先用pattern去匹配源string中的字符，匹配到了就用replace给替换掉。可以处理比较复杂的爬虫爬下来的包含html标签的文本。

一个简单的举例：

    text = 'pythonNLP9Pytorch125tensorFlow'
    pattern = '[0-9]{1,3}'
    result = re.sub(pattern,'**HelloWorld**',text)
    print(result)

上述代码就是用**HelloWorld**把text中的连续数字单位替换掉，结果显示：

pythonNLP**HelloWorld**Pytorch**HelloWorld**tensorFlow

6、re.findall(pattern,string)和re.finditer(pattern,string)

这个函数是我最喜欢用的函数，它能把满足pattern的结果全部从string中找出来，然后形成一个list返回。前者是返回list后者返回迭代器，每个元素可以使用group()得到文本，span()得到起始位置

    text = 'HYpythonNLP9Pytorch125tensorFlow,pythonNLPdjkdpythonNLP'
    pattern = 'pythonNLP'
    result = re.findall(pattern,text)
    print(result)

这里的代码就可以把text中的全部pythonNLP给找出来。结果如下：

['pythonNLP', 'pythonNLP', 'pythonNLP']

7、re.compile(pattern)

这里的作用是编译一个正则命令，在使用了很多次正则的情况下，能提高效率！这里很多次据网上分析得有百万千万级别。

这Python中，1-6的函数已经实现了re.compile(pattern)函数的功能，其实是可以不用的。我认为Python中这个函数的作用就不大了。搭配1-6函数的用法如下：

    text = 'HYpythonNLP9Pytorch125tensorFlow,pythonNLPdjkdpythonNLP'
    pattern = re.compile('pythonNLP')
    result = pattern.findall(text)
    print(result)

三、NLP中文本处理常用情形

这里总结一下，NLP中文本处理的一些常用正则表达式的骚操作。

1、电话号码匹配(包含座机号码和手机号码，不含合法性检测)

简单的分析一下手机号码和座机号码，手机号码一般是11位，后面8位是[0-9]之间任意选择的，而我国现在放出的号段，前三位严格限制，第一位是1，第二位一定是[3-9]，第三位不太清楚是不是有严格的限定，应该要去查询三大运营商开放的号段了。这里简单的理解是0-9。那么手机号码的正则就是：1[3-9][0-9][0-9]{8}，代码验证：

    number1 = '11033399889'
    number2 = '19987908888'

    pattern = '1[3-9][0-9][0-9]{8}'
    print('number1',number1)
    print('number2',number2)
    print('number1 is telephone number:',re.fullmatch(pattern,number1)!=None)
    print('number2 is telephone number:', re.fullmatch(pattern, number2)!=None)

结果：

(pytorch) huangyang@huangyang-Inspiron-7560:/media/huangyang/PycharmWorkspace/Python/pythonFundation/regular_expression$ python regular_expression.py 
number1 11033399889
number2 19987908888
number1 is telephone number: False
number2 is telephone number: True

座机号码：一般是2-3位的区号，有的时候拨打长途就要在区号前面+0；后面的号码一般是7-8位。书面表达的时候一般用-隔开，有的时候也没有。正则表达式是：'0?[0-9]{2}-?[0-9]{7,8}'，代码验证：

    number1 = '0276581098'
    number2 = '20-88887777'

    pattern = '0?[0-9]{2}-?[0-9]{7,8}'
    print('number1', number1)
    print('number2', number2)
    print('number1 is telephone number:', re.fullmatch(pattern, number1) != None)
    print('number2 is telephone number:', re.fullmatch(pattern, number2) != None)

结果显示：

(pytorch) huangyang@huangyang-Inspiron-7560:/media/huangyang/PycharmWorkspace/Python/pythonFundation/regular_expression$ python regular_expression.py 
number1 0276581098
number2 20-88887777
number1 is telephone number: True
number2 is telephone number: True

以上就是简单的对电话号码进行了一个分析，不含电话号码严格合法行验证。如果需要精确的验证，需要去分析具体的号码构成，以及现阶段国家和运营商放出的号码的规则。下面处理就按照简单的原则来分析，不做严格的判断。在文本中一般出现的都是一些合法的，只需要你把它提取出来。

# 固定电话号码
LANDLINE_PHONE_PATTERN = r'(?<=[^\d])(([\(（])?0\d{2,3}[\)） —-]{1,2}\d{7,8}|\d{3,4}[ -]\d{3,4}[ -]\d{4})(?=[^\d])'
非数字开头，和数字结尾的字符串中座机号码

LANDLINE_PHONE_CHECK_PATTERN = r'(([\(（])?0\d{2,3}[\)） —-]{1,2}\d{7,8}|\d{3,4}[ -]\d{3,4}[ -]\d{4})'
# 手机号码
CELL_PHONE_PATTERN = r'(?<=[^\d])(((\+86)?([- ])?)?((1[3-9][0-9]))([- ])?\d{4}([- ])?\d{4})(?=[^\d])'
非数字开头，和数字结尾的字符串中手机号码

2、邮箱的匹配(不含合法性检测)

找到一个规则：

1. 邮箱首字符和末尾字符必须为字母或数字，邮箱名可以全是字母或数字，或者是两者的组合；
2. 连字符"-"、下划线"_" 和英文句号点"."，仅能放在字母或数字中间，且不能连续出现（即其单个符号的左右只能是字母或数字）；
3. 域名可以带连字符"-"， 且可以是多级域名 ,还可以有多个域名后缀；
4. 不区分大小写；
5. 不限定邮箱字符串的具体长度

实现如下：

^[\da-z]+([\-\.\_]?[\da-z]+)*@[\da-z]+([\-\.]?[\da-z]+)*(\.[a-z]{2,})+$

3、身份证号码匹配

身份证号码一般由15位长度和18位长度。15位一般是45岁以上的老人使用的，我们现在的18位。根据规则，18位的身份证最后一位是和前面17位息息相关的，通过一个算法来计算的。这里我们不做这样的考虑直接0-9和X可取。

[0-9]{15}|[0-9]{17}[X0-9]

要精确的验证合法性就必须考虑省份、出生年月日的数字可能性，还有最后一位校验码的可能。

4、整体性和非的综合性匹配

这个是属于一种骚操作的。例如要提取出两个整体单位之间的字符串。

hello I am HY Over!djfajdkjsdklhello5454545 I am HY Over511212

要把hello和Over之间的内容及它们提取出来， hello I am HY Over和hello5454545 I am HY Over511212 ，这个就是我们期待的结果。

很容易想到：re.compile('hello.*Over')，结果却是：['hello I am HY Over!djfajdkjsdklhello5454545 I am HY Over']

不对，所以正则表示中需要把hello这个整体不能在hello.*Over'中的.*中出现，这里就涉及到非字符串的匹配。

需要用到断言(?!pattern)。上面这里就需要用到((?!hello).)*，表示非hello的字符匹配*。那么就修改为这样：re.compile('hello((?!hello).)*Over')，这里有个外层括号需要非获取匹配，最终修改为：re.compile('hello(?:(?!hello).)*Over')

实验验证代码：

    text = 'hello I am HY Over!djfajdkjsdklhello5454545 I am HY Over511212'
    pattern = re.compile('hello(?:(?!hello).)*Over')
    result = pattern.findall(text)
    print(result)

结果：

veilytech@veilytech-desktop:/media/veilytech/data/Huangyang/study/2020/python_foundation/regular_expression$ python regular_expression.py 
['hello I am HY Over', 'hello5454545 I am HY Over']

和我们期待的一样！

现有这样一个需求，提取以ab开头出现n次以上，cd结尾出现m次以上的字符串；这种又怎么匹配呢？

mn明年ji哈哈ababababxyabmnkiljxyxyxy大家好才是真的好ababab××××××××××××××#############xyxykkkkk
匹配ab出现3次到5次开头，xy出现2次以上结束的结果

这里就需要用到整体单位判断了！(?:ab)——ab作为一个整体去匹配，所以答案是这样！

    text = 'mn明年ji哈哈ababababxyabmnkiljxyxyxy大家好才是真的好ababab××××××××××××××#############xyxykkkkk'
    pattern = re.compile('((?:ab){3,5}.*(?:xy){2,})')
    result = pattern.findall(text)
    print(result)

结果如下：

ababababxyabmnkiljxyxyxy大家好才是真的好ababab××××××××××××××#############xyxy

那需要进一步优化，提取结果为这样呢？

ababababxyabmnkiljxyxyxy  和  ababab××××××××××××××#############xyxy

就需要把中间的ab满足匹配的情形去掉，修改为如下：

pattern = re.compile('((?:ab){3,5}(?:(?!(?:ab){3,5}).)*(?:xy){2,})')
(?:(?!(?:ab){3,5}).)*改变的部分在这里，就是把中间ab出现3-5次的情形去掉

验证：

    text = 'mn明年ji哈哈ababababxyabmnkiljxyxyxy大家好才是真的好ababab××××××××××××××#############xyxykkkkk'
    pattern = re.compile('((?:ab){3,5}(?:(?!(?:ab){3,5}).)*(?:xy){2,})')
    result = pattern.findall(text)
    print(result)

结果如下：

veilytech@veilytech-desktop:/media/veilytech/data/Huangyang/study/2020/python_foundation/regular_expression$ python regular_expression.py 
['ababababxyabmnkiljxyxyxy', 'ababab××××××××××××××#############xyxy']

满足我们期待的结果。
 

总结

正则表达式这个是需要多写多练的，掌握基本的匹配规则然后，针对特定的需求，进行组合！