发表AI 秘籍 / Python

17. 正则表达式

Hi，大家好。我是茶桁。

不知不觉中，咱们针对人工智能的 Python 课程已经过去了一半。相信大家这段时间也都有所进步了。

今天这节课呢，我给大家划一个重点。不仅仅是 Python，很多语言里都是通用的，而且非常的强大。这就是我们的正则表达式。

说起正则表达式，很多程序员其实对其都不是很重视，但是学好它，必定在处理数据的时候事倍功半。虽然内容看似不多，但是市面上有一本经典的「精通电子表达式」整本书还是非常厚的。当然，它比咱们今天要讲的内容详尽的多了。听完我这节课之后想继续研究正则的小伙伴，推荐这本书（唯一推荐）。

正则表达式是什么呢？其实就是使用字符、转义字符和特殊字符组成一个规则，使用这个规则对文本的内容完成一个搜索或匹配或替换的功能。

正则表达式的组成

正则表达式内，包含了普通字符，转义字符，特殊字符以及匹配模式：

1
2
3
4
普通字符： 大小写字母，数字，符号...
转义字符： \w, \W, \d, \D, \s, \S ...
特殊字符： . * ? + ^ $ [] {} () 
匹配模式： I U ...

接下来我们看几个栗子：

1
2
3
4
5
6
7
8
9
10
11
# 定义字符串
myStr = 'iloveyou521tosimida'
# 定义正则
myReg = 'love'

# 调用正则函数方法
res = re.findall(myReg, myStr)
print(res)

---
['love']

这样，我们就匹配了一个字符串。如果我们想匹配数字，那myReg=521就能够匹配了。不过，现在我有一个新需求，我们重新定义一下myStr = 'iloveyou521to123simida'， 我们可以看到，这个字符串十分的混乱，数字和字母都是混在一起的。现在，我就想把数字都单独的拎出来，又该怎么做呢？来，让我们试试看：

1
2
3
4
5
6
7
8
myStr = "iloveyou521to123simida"
myReg = '\d'
# 调用正则表达式相关函数
res = re.findall(myReg, myStr)
print(res)

---
['5', '2', '1', '1', '2', '3']

这样，我们使用\d这个转义字符匹配到了字符串内相关的所有数字，返回了一个列表。

可是这还是不符合我们的要求，我们想要的是将其中的数字组合匹配出来，而不是单独的数字。接着继续改：

1
2
3
4
5
6
7
8
myStr = "iloveyou521to123si7894mida"
myReg = '\d\d\d'
# 调用正则表达式相关函数
res = re.findall(myReg, myStr)
print(res)

---
['521', '123', '789']

将原本一个\d改为了三个叠在一起的\d\d\d， 这样，我们匹配到了三位数字的组合。注意，我在原本的字符串内又加入了一个四位的数字组合7894，但是也只匹配出了789，那也就是说，这种数字匹配方式，有几个转义字符组合在一起，那就匹配出多少位; \d这个转义字符就是代表单个的数字。

整个代码中，findall就是正则中的相关函数，除了findall之外，还有一些其他函数，我们一起来认识下：

re模块的函数

match与search

match和search经常是被放在一起来进行讨论的，因为这两个函数很像。具体它们有什么作用和区别呢？我们直接上代码，一点点讲：

1
2
3
4
5
6
print(re.match('www', 'www.hivan.me').span()) # 起始位置匹配
print(re.match('me', 'www.hivan.me')) # 不在起始位置匹配

---
(0, 3)
None

可以看到，虽然第二段打印中，我输入的me也可以从字符串中找到，但是因为不是从起始位置匹配的，所以返回了None。

再来看看search：

1
2
3
4
5
6
print(re.search('www', 'www.hivan.me').span()) # 起始位置匹配
print(re.search('me', 'www.hivan.me').span()) # 不在起始位置匹配

---
(0, 3)
(10, 12)

search方法中，无论我们要匹配的字符是在起始位置还是结束位置，只要是能找到，都会返回其位置。

有小伙伴们可能会奇怪，我在成功返回的末尾都加了一个span(), 是不是这个影响的原因？我们来看看这两个方法匹配成功后的返回值就明白了：

1
2
3
4
print(re.search('me', 'www.hivan.me')) # 不在起始位置匹配

---
<re.Match object; span=(10, 12), match='me'>

其完整的返回值应该是这样的，我后面加的span()只是为了获取返回值中的span信息。

所以对于这两个函数，我们可以稍微归纳一下：

re.match()函数：

  • 会从头开始进行匹配，如果第一个就符合要求，那么匹配成功
  • 如果第一个不符合规则，则返回None
  • 匹配成功后返回Match对象
  • 成功后可以使用group()和span()方法获取数据和下标区间

re.search()函数：

  • 从字符串的开头开始进行搜索式的匹配
  • 匹配成功则返回Match对象，匹配失败者返回None
  • 成功后可以使用group()和span()方法获取数据和下标区间

两者的区别：

  • match方法是从字符串的开头进行匹配，如果开始就不符合正则的要求，则匹配失败，返回 None。
  • search方法是从字符串的开始位置一直搜索到字符串的最后，如果在整个字符串中都没有匹配到，则失败，返回 None

在看完match和search之后，我们再来看看re模块的其他函数：

re.findall()

这个函数在文章开头我们就用到了，但是并未给大家进行详解。现在我们就来认识一下：

1
2
3
4
5
6
myStr = "iloveyou521to123si7894lovemida"
myReg = 'love'
print(re.findall(myReg, myStr))

---
['love', 'love']

可以看到，和一开头我们所写的不同，这次返回的参数列表内出现了两个love， 原因就是我对myStr这个变量又重新定义了一下，在接近尾部的地方多加了一个love。

从这我们也能看出来了，findall这个函数是按照正则表达式的规则在字符中匹配所有符合规则的元素，结果返回一个列表，如果没有找到的情况下，会返回一个空列表。

re.finditer()

1
2
3
4
5
res = re.finditer(myReg, myStr)
print(res)

---
<callable_iterator object at 0x107ab3790>

从返回的结果中看到，这个函数返回的是一个迭代器。那让我们利用迭代器规则来试试看：

1
2
3
4
5
6
7
8
print(next(res))
print(next(res))
print(next(res))

---
<re.Match object; span=(1, 5), match='love'>
<re.Match object; span=(22, 26), match='love'>
StopIteration:

在第三个next方法的时候报错了，那和我们使用findall结果是一致的，返回了两个love。并且，finditer方法会返回每一个匹配值的下标范围。使用span()来获取到这个范围。

re.sub()

这个函数方法和之前介绍的方法有些不太一样了，以上我们所使用的可以说都是搜索、查找。那这个函数就是修改了。其功能是按照正则表达式的规则，在字符串中找到需要被替换的字符串，完成一个替换。主要参数有三个：

  • pattern: 正则表示的规则，匹配需要被替换的字符串
  • repl: 替换后的字符串
  • string: 被替换的原始字符串
1
2
3
4
5
6
7
myStr = "iloveyou521to123si7894lovemida"
myReg = 'love'
res = re.sub(myReg, 'live', myStr)
print(res)

---
iliveyou521to123si7894livemida

这样，我们对整个myStr就完成了特定字符串的替换，将其中的love全部替换成了live。

re.split()

这个方法会按照指定的正则规则，进行数据切割。

1
2
3
4
5
6
myStr = 'hello my name is chaheng'
res = re.split(' ', myStr)
print(res)

---
['hello', 'my', 'name', 'is', 'chaheng']

在这段代码中，我们将原字符串以空格来进行风格，将整个字符串分割成了一个列表。其原理和我们将字符串时讲到的基本一致，这里就不详细讲解这个函数了。

compile()

这个函数可以直接将正则表达式定义为「正则对象」， 使用正则对象直接操作。

我们现在来看一个示例：

假如说，我有下面这样一个列表：

1
2
3
4
5
6
arr = [
    'i love 123 you',
    'i love 234 you',
    'i love 456 you',
    'i love 678 you'
]

我现在想要从中找到所有的数字，那么使用之前所学的内容，当然我们想到的一定是for循环。

1
2
3
4
5
6
7
8
9
10
for i in arr:
    newReg = '\d\d\d'
    res = re.search(newReg, i)
    print(res.group())
    
---
123
234
456
678

可以看到，我们确实正确的拿到了arr中的相关数字。

这里，我们稍微讲解一下正则表达式中的\d{n}， 在正则中，\d是转义字符我们之前学过了，但是其实，我们并不需要写三个\d来去匹配三个数字，那如果真是这样的话，我们要匹配几十个数字的时候怎么办呢？这个时候我们可以用到\d{n}这样的写法，大括号中的n表示的就是前面这个\d的匹配连续匹配 n 次。那么，我们原本的newReg='\d\d\d'就可以改为newRge='\d{3}'。

让我们回过头来继续，刚才我们使用了for循环来完成了依次取值对吧。这个时候，让我们深入search()这个方法的源码去看看，其中是长这样的：

1
2
def search(pattern, string, flags=0):
  return _compile(pattern, flags).search(string)

那么根据这个return的结构来看，我们是不是可以这样来写：

1
2
3
4
5
6
7
8
9
10
myReg = re.compile('\d{3}')
for i in arr:
    res = myReg.search(i).group()
    print(res)
    
---
123
234
456
678

确实，我们获得了我们想要的结果。

那上下两种写法的区别在于哪里呢？

其实，我们第一种写法里，我们定义了一个正则规则，然后传给search(myReg, i)之后，search方法在其内部先是调用了一下_compile, 生成了一个正则对象，在这之后，才又传给了search方法，最后得到结果。

而我们在第二种写法中，直接用compile函数将规则定义成了一个对象，使用search直接得到了结果。

你们注意看结构，是不是我第二个写法里，for循环里的myReg实际上就是search方法内的_compile(pattern, flags)。

那我们这样写有什么意义呢？呃，实际上，从性能上来说虽然是快了一些，但是也不见得快多少。更多的是想让大家养成一个去方法源码中探究逻辑的好习惯。

那么接下来，才是这节课的重点。大家集中注意力，我们开始。

正则表达式的规则

在本文的最开头，我们就先给到了正则表达式的基本规则，我们拿下来再复习一下：

1
2
3
4
普通字符： 大小写字母，数字，符号...
转义字符： \w, \W, \d, \D, \s, \S ...
特殊字符： . * ? + ^ $ [] {} () 
匹配模式： I U ...

那其实，我们之前介绍相关函数方法的时候，所使用到的基本都是普通字符，其中也用到了\d这个转义字符，明白\d就是去匹配数字。

普通字符

普通字符实际上就是最简单的匹配方式，你写什么就是什么。可以理解为，我在全文中去搜索一个单词或者数字。而且我们之前也使用过多次了，所以这部分我们就不再继续向西介绍了。

转义字符

转义字符包括：\w, \W, \d, \D, \s, \S ...

什么都是从代码里去理解最直接，让我们先来定义一个字符串待用：

1
myStr = 'a2$_ilove5	21you'

然后我们一个一个来看：

\w, 这个转义字符匹配的内容是单个字母、数字、下划线

1
2
3
4
5
6
myReg = '\w'
res = re.findall(myReg, myStr)
print(res)

---
['a', '2', '_', 'i', 'l', 'o', 'v', 'e', '5', '2', '1', 'y', 'o', 'u']

我们看，在最后的结果中，我们匹配到了这个字符串中所有的字母，数字和下划线。其中的特殊字符和制表符都被过滤掉了。

\W， 注意，现在这个W是大写的。那这个转义字符规则会去匹配单个「非」字母、数字，下划线。啥意思？简单，看代码：

1
2
3
4
5
6
7
# 转义字符
myReg = '\W'
res = re.findall(myReg, myStr)
print(res)

---
['$', '\t']

看到区别了吧？和\w(小写)完全相反，之前匹配到的字母、数字、下划线一个没匹配到，而之前没被匹配到的特殊字符和制表符，则被匹配后组成了一个列表。

\d，这个转义字符规则会匹配单个的数字。这个我们之前用过了，这里就不演示了。

\D， 这个转义字符实际也非常简单，就是匹配非数字。注意到了吧？所有的转义字符里，小写字母大写之后，其匹配的内容都是相反的。

1
2
3
4
5
6
myReg = '\D'
res = re.findall(myReg, myStr)
print(res)

---
['a', '$', '_', 'i', 'l', 'o', 'v', 'e', '\t', 'y', 'o', 'u']

结果也是，除了数字其他的内容都被匹配到了。

\s， 这个转义字符规则是匹配单个的空格符或制表符。

1
2
3
4
5
6
myReg = '\s'
res = re.findall(myReg, myStr)
print(res)

---
['\t']

结果却是如此，唯一的制表符被匹配了出来。（初学时，我一度长期混乱的认为\s是匹配所有字符串，大家别犯我一样的错误。）

\S，那这个大写字母的匹配规则不用说，一定是匹配空格或制表符之外的所有内容：

1
2
3
4
5
6
myReg = '\S'
res = re.findall(myReg, myStr)
print(res)

---
['a', '2', '$', '_', 'i', 'l', 'o', 'v', 'e', '5', '2', '1', 'y', 'o', 'u']

打印结果验证了我们的猜想。

\w{4}\d， 基本转义字符我们都介绍完了，这里我们来看看组合在一起会是什么样。其中的\w{4}大家也应该明白其含义，就是\w\w\w\w。

1
2
3
4
5
6
myReg = '\w{4}\d'
res = re.findall(myReg, myStr)
print(res)

---
['love5']

可以看到，这样组合之后匹配出来的就是 4 个字母、数字、下划线+一个数字。那是不是这次匹配我们也可以写成\w{5}呢？反正最后匹配出来的love5不也就是 5 个w的组合么？

那我们试试看就知道了：

1
2
3
4
5
6
myReg = '\w{5}'
res = re.findall(myReg, myStr)
print(res)

---
['_ilov', '21you']

没想道结果是这样的对吧？这是因为，\w{5}中，最后一位可以是字母，数字或者下划线都可以，而我们用\w{4}\d则是最后一位必须是数字，不能是其他的。

特殊字符

特殊字符包括：. * ? + ^ $ [] {} ()

这回，让我们再重新定义一段合适的字符串

1
myStr = '@	_2i4l22oveyou'

然后，我们还是一个一个的来看：

.，表示匹配单个的任意字符，当然也有例外，就是除了换行符。

1
2
3
4
5
6
myReg = '.'
res = re.findall(myReg, myStr)
print(res)

---
['@', '\t', '_', '2', 'i', '4', 'l', '2', '2', 'o', 'v', 'e', 'y', 'o', 'u']

字符串内的所有内容，我们都匹配了出来，然后组成了一个列表。

*, 这个特殊字符需要和其他的匹配进行组合使用，它表示的是任意次数。具体什么意思呢？我们还是从代码里去看看是如何表现的：

1
2
3
4
5
6
7
myStr = 'like chaheng @	_2i4l22oveyou'
myReg = '\w'
res = re.search(myReg, myStr)
print(res.group())

---
l

这段代码我们应该是比较熟悉了，\w和search方法我们都已经学过了。那这个其实就是在字符串中从开头去匹配\w对吧？

我们再来继续往下看：

1
2
3
4
5
6
7
myStr = 'like chaheng @	_2i4l22oveyou'
myReg = '\w*'
res = re.search(myReg, myStr)
print(res.group())

---
like

我们看结果，这次search在匹配到第一个\w之后，又继续向后匹配了，直到遇到空格才停了下来。就是因为\w后面加了一个*, 所以就会一直匹配任意次数，直到\w不再匹配了才结束。

这里有一个概念，就是*代表的匹配任意次数，为什么我要强调这个呢？就是任意次数其实是包含0次的。也就是说，我们只要使用了*这个特殊字符，那么就算没有符合匹配项，一样是酸是匹配成功了，只是返回的是空而已。我们来看看：

1
2
3
4
5
6
7
myStr = ' like chaheng @	_2i4l22oveyou'
myReg = '\w*'
res = re.match(myReg, myStr)
print(res)

---
<re.Match object; span=(0, 0), match=''>

我们在之前的字符串前面加了一个空格，按道理说是不符合\w匹配的。那么match从字符串的开头开始进行搜索式的匹配,没有就返回None对吧？可是这次，并没有返回None，我们看到match=''， 也就是说，它匹配成功了，只是成功了 0 次。所以按照*匹配任意次的规则，它不会返回None。这里比较绕，大家好好理解一下。我们继续。

+， 这又是一个和其他规则配合使用的特殊字符，和*一样，它也表示匹配次数，但是这个表示的是至少要求匹配一次。正好，我们之前改造的字符串最前面多加了一个空格，让我们来看看：

1
2
3
4
5
6
myReg = '\w+'
res = re.search(myReg, myStr)
print(res.group())

---
like

按search从字符串的开头开始进行搜索式的匹配，是不是这里我们应该返回l了？然而并没有，却返回了like，这是为什么呢？

原因就在于+这个特殊字符，它也并不是只拿到第一个就罢休了，和\w*一样，一直往后匹配，直到第二个空格的时候，才宣告罢休。所以\+是「至少」匹配一次，0次不干，而1之后如果可以连续，那就继续匹配。

?, 这个特殊字符的作用是「拒绝贪婪」，看着很特殊是吧？其实就是，在?之前的规则，只要达成即可。

1
2
3
4
5
6
myReg = '\w+?'
res = re.search(myReg, myStr)
print(res.group())

---
l

看，我们之前使用\w+的时候，+这孩子遇到第一个还不满足，非要向后继续拿。可是这个时候我多加了一个家长?，勒令+既然目的已经达到了，就不要再继续了。这就是?字符「拒绝贪婪」的作用。

{}， 这个特殊字符咱们用过了，应该大家也都知道它的含义。就是重复多少次。

1
2
3
4
5
6
myReg = '\w{5}'
res = re.search(myReg, myStr)
print(res.group())

---
chahe

从结果我们可以看到，因为前面的like只有四位，并不符合连续匹配五次的标准，所以最后被匹配出来的是chahe。

{}这个特殊字符其实还有一种用法，就是可以给定范围。

1
2
3
4
5
6
myReg = '\w{1,4}'
res = re.search(myReg, myStr)
print(res.group())

---
like

我们知道，下标 1 到下标 4 这个范围内，正好是like。

‘[]’， 这个特殊字符代表字符的范围。用于匹配范围内说包含的字符。使用[]我们可以更精准的筛选出我们需要匹配的内容。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
myStr = 'like chaheng @	 ShO _2i4l22LoveYou'
myReg = '[A-Z]'
res = re.findall(myReg, myStr)
print(res)
myReg = '[a-z]'
res = re.findall(myReg, myStr)
print(res)
myReg = '[0-9]'
res = re.findall(myReg, myStr)
print(res)
myReg = '[_]'
res = re.findall(myReg, myStr)
print(res)

---
['S', 'O', 'L', 'Y']
['l', 'i', 'k', 'e', 'c', 'h', 'a', 'h', 'e', 'n', 'g', 'h', 'i', 'l', 'o', 'v', 'e', 'o', 'u']
['2', '4', '2', '2']
['_']

可以看到，不同的组合匹配出了不同的范围内的单个字符。

[A-Za-z0-9_] 这个组合等价于\w。

1
2
3
4
5
6
7
myStr = 'like chaheng @	 ShO _2i4l22LoveYou'
myReg = '[A-Za-z0-9_]'
res = re.findall(myReg, myStr)
print(res)

---
['l', 'i', 'k', 'e', 'c', 'h', 'a', 'h', 'e', 'n', 'g', 'S', 'h', 'O', '_', '2', 'i', '4', 'l', '2', '2', 'L', 'o', 'v', 'e', 'Y', 'o', 'u']

(),这个特殊字符代表的子组，括号中的表达式首先作为整个正则的一部分，另外会把符合小阔中的内容单独提取一份。我们先看一段代码：

1
2
3
4
5
6
7
myStr = 'like chaheng @	 ShO _2ial2345LoveYou'
myReg = '\w+\d{4}\w+'
res = re.findall(myReg, myStr)
print(res)

---
['_2ial2345LoveYou']

这个组合我们匹配到了_2ial2345LoveYou， 有且只有这一个组合了。不过这不是我想要的，我想要的是什么呢？是这段匹配出的字符串，并且，我还想要这段字符串中那段数字作为单独的匹配出来。那这个时候我们怎么做呢？

1
2
3
4
5
6
7
myStr = 'like chaheng @	 ShO _2ial2345LoveYou'
myReg = '(\w+)(\d{4})(\w+)'
res = re.findall(myReg, myStr)
print(res)

---
[('_2ial', '2345', 'LoveYou')]

我们将用()将前中后包裹了起来，希望得到一个子组，而中间的部分，就是我们想要得到的 4 个数字的组合。

^和$这两个特殊字符实际上属于「定位符」，^是匹配输入字符串开始的位置。$是匹配输入字符串结尾的位置。

那我们从一个案例中来了解一下这两个定位符的使用：

1
2
3
4
5
6
7
8
myStr = '186301916675'
# 定义一个匹配手机号的正则表达式
myReg = '^1\d{10}$'
res = re.search(myReg, myStr)
print(res)

---
None

返回了None， 这又是为什么呢？原因就在于，我们用^限制了必须是 1 开始，而用了$来限制了到结尾必须是后面有十位数字，而我们数一下，我们给定了 12 位数字，超出了一位，才会匹配不上。

如果我们去掉限制结尾$再来看看：

1
2
3
4
5
6
7
8
myStr = '186301916675'
# 定义一个匹配手机号的正则表达式
myReg = '^1\d{10}'
res = re.search(myReg, myStr)
print(res.group())

---
18630191667

可以看到，我们遵循了开头位 1 和后面跟十位数字的规则，但是原字符串中多出来的一位数字被直接过滤掉了。那我们并不知道，用户输入的数字中到底是哪个位置多输入了一个数对吧？

再来看，我们把结尾限制加上，但是开头限制改一个数字：

1
2
3
4
5
6
7
8
myStr = '186301916675'
# 定义一个匹配手机号的正则表达式
myReg = '^2\d{10}$'
res = re.search(myReg, myStr)
print(res)

---
None

因为开头匹配不对，所以返回了None。

所以，争取的匹配方式至少有三个条件：

  1. 1 开头， 当然，如果能把运营商的所有开头数字都拿到，那我们能够匹配的条件就变多了。
  2. 必须全部是数字
  3. 必须是 11 位

这样，我们可以加上开头限制和结尾限制，正好能满足一个简易的手机号匹配规则：

1
'^1\d{10}$'

正则的模式

在正则的模式中，包含了一下几个模式：

re.I: 不区分大小写

re.L: 作本地化识别匹配

re.M: 多行匹配，会影响到^个$

re.S：使用.匹配包括换行在哪的所有字符

re.U：根据Unicode字符集解析字符。这个标志影响\w, \W, \b, \B

re.X: 改标志通过给予更灵活的格式以便将正则表达式写的更易于理解。

实际上，我们虽然列出了这么多模式，真正常用的，也就是re.I这个模式：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
# 正常匹配，给定规则大写字母
myStr = 'like chaheng @	 ShO _2i4l22LoveYou'
myReg = '[A-Z]'
res = re.findall(myReg, myStr)
print(res)

# 使用模式're.I'， 其他不变
myReg = '[A-Z]'
res = re.findall(myReg, myStr,re.I)
print(res)

---
['S', 'O', 'L', 'Y']
['l', 'i', 'k', 'e', 'c', 'h', 'a', 'h', 'e', 'n', 'g', 'S', 'h', 'O', 'i', 'l', 'L', 'o', 'v', 'e', 'Y', 'o', 'u']

可以看到，当我设定了不区分大小写的情况下。字符串中的所有英文字母都被匹配了出来。

练习：

这次，我们和以往不同，将练习和课程放在了一起。至于为什么嘛，只是因为我课程写完之后发现还有时间。^_^

这次我们作这样一个练习：

1
2
3
1. 定义一个正则表达式来验证邮箱是否正确。
2. 完善手机号码的正则表达式
3. 定义一个匹配 IP 的正则表达式 [255.255.255.254]

验证邮箱

首先让我们来看，邮箱的格式基本包含以下内容：

  • 123456@qq.com 纯数字
  • chaheng@qq.com 纯字母
  • chaheng75@126.com 数字加字母
  • cha_heng@163.com 混合型
  • chaheng@vip.163.com 多级域名
  • chaheng@hivan.me 企业邮箱（企业域名）
  • cha.heng@gmail.com 包含特殊字符.

好，让我们来看，我们以@来前后区分，那么我们先看左边，会包含的内容就是数字，字母，下划线，特殊字符，让我们先来写一下规则试一下：

[a-zA-Z0-9]+([_\.][a-zA-Z0-9])*

那么右边的部分呢？

@(\w)+\.[a-z]{2,6}

让我们结合其实试试看：

1
2
3
4
5
6
7
8
9
10
11
12
def mailReg(mail):
    myReg = '[a-zA-Z0-9]+([_\.][a-zA-Z0-9]+)*@(\w)+\.[a-z]{2,6}'
    res = re.search(myReg, mail)
    if res:
        return res.group()
    else:
        print(res)
    
mailReg('123456@qq.com')

---
'123456@qq.com'

感觉是 OK。那让我们多测试下试试：

1
2
3
4
5
6
7
8
9
10
mailReg('cha.heng@gmail.com')

---
'cha.heng@gmail.com'

=========================
mailReg('chaheng@vip.163.com')

---
None

多级域名的测试没有通过，在函数内打印出了None。我们回过头来看看：

1
myReg = '[a-zA-Z0-9]+([_\.][a-zA-Z0-9]+)*@(\w)+\.[a-z]{2,6}'

既然是多级域名出现了问题，那问题肯定出现在多出的那一个点上，我们这样改：

1
myReg = '^[a-zA-Z0-9]+([_\.][a-zA-Z0-9]+)*@(\w+\.)+[a-z]{2,6}$'

注意，我们加上了^和$符号。

然后我们再重新试试看，这次呢，我不想一个个实验了，让我们来定义一个数组来批量测试：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
def mailReg(mail):
    myReg = '^[a-zA-Z0-9]+([_\.][a-zA-Z0-9]+)*@(\w+\.)+[a-z]{2,6}$'
    for i in mail:
        res = re.search(myReg, i)
        if res:
            print(res.group())
        else:
            print(res)

emailarr = [
   '123456@qq.com',
   'chaheng@qq.com',
   'chaheng75@126.com',
   'cha_heng@163.com',
   'chaheng@vip.163.com',
   'chaheng@hivan.me',
   'cha.heng@gmail.com',
   ' list@gmail.com '
]

mailReg(emailarr)

---
123456@qq.com
chaheng@qq.com
chaheng75@126.com
cha_heng@163.com
chaheng@vip.163.com
chaheng@hivan.me
cha.heng@gmail.com
None

这一下子我们就将刚才想到的格式都测试完了，最后我们还特意加了一个不符合的格式来测试下康康是否被过滤了出来。结果说明我们写的正则没有问题。

手机号码

就像我们上面写验证手机号正则提到过的，我们可以定义一个所有运营商可能的开头来做头部验证：

1
13[0-9],14[5-9],15[0-3,5-9],16[2,5,6,7,8],17[0-8],18[0-9],19[0-3,5-9]

实际上，我们还可以分的更细一点，区分运营商。不过在这个练习中，没必要分的这么细了。

来，我们实现一下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
myReg = '^(13[0-9]|14[5-9]|15[0-3,5-9]|16[2,5,6,7,8]|17[0-8]|18[0-9]|19[0-3,5-9])\d{8}$'

phonearr = [
    '13728739429',
    '13128319520',
    '17729231234',
    '23210023421',
    '189232198341',
    '19123214421'
]

for i in phonearr:
    res = re.search(myReg, i)
    if not res:
        print('手机号码不正确:', i)
    else:
        print(res.group())
        
---
13728739429
13128319520
17729231234
手机号码不正确: 23210023421
手机号码不正确: 189232198341
19123214421

正确的辨认并打印了出来，不正确的也辨认了出来。

匹配 IP 地址

我们来看看，一个正确的 IP 地址（IPv4），是由四个三位数来组成的，包含：

1
0.0.0.0 ~ 255.255.255.255

既然是这样一个格式，我们来思考一下，

首先，我们需要匹配0 ~ 199的范围，也就是 0 或者 1 开头,这个比较简单：

1
[0-1]?\d{1,2}

这一段匹配中：

  • [0-1]?表示匹配 0 或 1 一次或者零次

  • \d就是要匹配任意单个数字。0～9 都可以

  • {1,2}， 给定范围 1 ～ 2， 表示前面的\d出现 1 次或者 2 次。

然后我们需要来匹配200 ~ 255范围, 这个范围内比较复杂，包含了两种情况，一种是201 ~250的情况，一种是251 ~ 255的情况

1
2((5[0-5])|([0-4][0-9]))

这一段匹配，一开表示数字2开头

然后 2 之后用异或限定了开头可以是5或者可以是0-4之间的任意数字。

是5的话，后面需要匹配 0-5，是4的话，后面需要匹配0-9`。

既然一次的匹配已经有了，那剩下的和第一次也都一样，就好些了，我们再多加一个.的匹配：

1
((2((5[0-5])|([0-4]\d)))|([0-1]?\d{1,2}))(\.((2((5[0-5])|([0-4]\d)))|([0-1]?\d{1,2}))){3}

让我们来试试：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
myReg = '((2(5[0-5]|[0-4]\d))|[0-1]?\d{1,2})(\.((2(5[0-5]|[0-4]\d))|[0-1]?\d{1,2})){3}'


ipArr = [
    '25.232.123.241',
    '123.242.211.221',
    '0.0.123.421',
    '123.421.4.5',
    '212.444.523',
    '0.0.0.0',
    '214.113.231.256',
    '54.214.213.265'
]

for i in ipArr:
    res = re.search(myReg, i)
    if not res:
        print('IP 地址不正确:', i)
    else:
        print(res.group())

---
25.232.123.241
123.242.211.221
0.0.123.42
IP 地址不正确: 123.421.4.5
IP 地址不正确: 212.444.523
0.0.0.0
214.113.231.25
54.214.213.26

从结果中可以看到，到底还是有漏网之鱼。第三个和最后两个判断都失误了。这是为什么呢？

似乎最后一位被截断判断了，也就是说，它并没有判断三位数。

哦，我大概猜到了。让我们把头部匹配和结尾匹配加上再试试：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
myReg = '^((2(5[0-5]|[0-4]\d))|[0-1]?\d{1,2})(\.((2(5[0-5]|[0-4]\d))|[0-1]?\d{1,2})){3}$'


ipArr = [
    '25.232.123.241',
    '123.242.211.221',
    '0.0.123.421',
    '123.421.4.5',
    '212.444.523',
    '0.0.0.0',
    '214.113.231.256',
    '54.214.213.265'
]

for i in ipArr:
    res = re.search(myReg, i)
    if not res:
        print('IP 地址不正确:', i)
    else:
        print(res.group())

---
25.232.123.241
123.242.211.221
IP 地址不正确: 0.0.123.421
IP 地址不正确: 123.421.4.5
IP 地址不正确: 212.444.523
0.0.0.0
IP 地址不正确: 214.113.231.256
IP 地址不正确: 54.214.213.265

这回没问题了。我们的正则匹配算是完成了。

那这节课下来之后，大家要多去理解，多去练习。这节课对于打算玩数据的人正的很重要。

好了，那我们下节课再见吧。

17. 正则表达式

https://hivan.me/regular-expression/

作者

Hivan Du

发布于

2023-08-13

更新于

2024-01-16

许可协议

#

喜欢这篇文章？打赏一下作者吧

评论

关注我

链接

分类

最新文章

×