Day 17

补充

• 重载：
  函数的重载 -- 函数名相同但是参数不同的函数可以有多个，但是python不支持函数的重载

1. 正则表达式-符号（regular）

import re

1. 讲解

   • 正则表达式就是做字符串匹配的一种工具，很多语言都支持正则语法，正则语法是通用的。
   • python中通过re模块中提供的方式来使用正则。
   • re.fullmatch(正则表达式, 字符串) -- 完全匹配，检查字符串是否满足正则表达式的要求；如果不匹配结果就是None，匹配结果是一个匹配对象。
   • python正则表达式 -- r'正则' (r-阻止转义)
   • js正则表达式 -- /正则/

2. 匹配字符的符号
   1）普通字符
   普通字符在正则中代表字符本身，例如：a, b, 1...等
   要求一个字符串有5个字符，分别是h, e, l, l, o

   re_str = r'hello'
   result = re.fullmatch(re_str, 'hello')
   print(result)
   

   2）.(匹配除换行符以外的任意字符)
   一个.匹配一个除换行符以外的任意字符
   [^\n] == .
   匹配一个字符串有三个字符，第一个字符是a，最后一个字符是c，第二个字符是任意字符

   re_str = r'a.c'
   result = re.fullmatch(re_str, 'a+c')
   print(result)
   

   3）\w（匹配字母、数字、下划线）
   一个\w只能匹配一个字符
   注意：这个不严谨，还可以匹配中文等字符,不能匹配ASCII码表中除了字母数字下划线以外的符号。
   匹配一个字符串第一个字符是字母、数字、下划线，后面是'abc'

   re_str = r'\wabc'
   result = re.fullmatch(re_str,'_abc')
   print(result)
   

   4）\s(匹配空白字符)
   空白字符：空格、\t、\n
   一个\s只能匹配一个空白字符
   匹配一个长度是8的字符，要求前三个字符是任意字符，中间两个空白字符，后面再三个任意字符

   re_str = r'...\s\s...'
   result = re.fullmatch(re_str, 'sdf\t\nsdf')
   print(result)
   

   5）\d(匹配数字字符)

   re_str = r'\d\dabc'
   result = re.fullmatch(re_str, '34abc')
   print(result)
   

   6）\W(非数字、字母、下划线)
   7）\S(非空白字符)
   匹配一个长度是4的字符，后面三个字符是'abc'，第一个字符可以是任何一个非空白字符

   re_str = r'\Sabc'
   result = re.fullmatch(re_str, '2abc')
   print(result)
   

   8）\D(匹配非数字字符)

   re_str = '\Dabc'
   result = re.fullmatch(re_str, 'sabc')
   print(result)
   

   9）[](匹配字符集中的一个字符)

   a.[普通字符集]  --  匹配字符集中的任意一个字符
   b.[字符1-字符2]  --  匹配字符1到字符2中的任意一个字符(要求  字符1的编码值小于字符2)
   [0-9]  --  匹配所有的数字
   [a-z]  --  匹配小写字母
   [A-Z]  --  匹配大写字母
   [a-zA-Z]  --  匹配所有的字母
   [\da-zA-Z_]  --  匹配字母数字下划线
   [\u4e00-\u9fa5]  --  匹配所有的中文
   注意：一个[]只能匹配一个字符
   

   匹配一个长度是4的字符串，第一个字符是x或者y或者z，后面是abc

   re_str = r'[xyz]abc'
   result = re.fullmatch(re_str, 'xabc')
   print(result)
   

   匹配一个长度是4 的字符串，第一个字符是数字或者x, y, z

   re_str = r'[\dxyz]abc'
   result = re.fullmatch(re_str, '4abc')
   print(result)
   

   匹配一个长度是4的字符串，第一个字符是数字字符2-8中的一个或者是x,y,z

   re_str = r'[2-8xyz]abc'
   result = re.fullmatch(re_str, '3abc')
   print(result)
   

   匹配一个长度是4的字符串，第一个字符是汉字

   re_str = r'[\u4e00-\u9fa5]abc'
   result = re.fullmatch(re_str, '以abc')
   print(result)
   

   • [^]

   [^字符集]  --  匹配不在字符集中任意一个字符
   [^\u4e00-\u9fa5]  --  匹配一个非中文字符
   ...
   

   匹配一个长度是4的字符串，第一个字符不是中文字符

   re_str = r'[^\u4e00-\u9fa5]abc'
   result = re.fullmatch(re_str, '7abc')
   print(result)
   

3. 检测字符的符号
   1）\b(检测单词边界)

   \b  --  检查\b所在的位置是否是单词边界
   单词边界  --  字符串开头、字符串结尾、空白、标点符号等
   

   匹配一个长度是4的字符串，第一个字符是任意字符，后边是abc；检查c的后面是否是单词边界

   re_str = r'.abc\b,are'
   print(re.fullmatch(re_str, '7abc,are'))
   

   2）^（检查是否是字符串开头）

   re_str = r'^abc'
   print(re.fullmatch(re_str, 'abc'))
   print(re.search(r'\d\d', 'has34ahfskf'))
   

   3）$(检测是否是字符串结尾)

   re_str = r'sfj$'
   print(re.fullmatch(re_str, 'sfj'))
   print(re.search(r'\d\d$', 'hello45'))
   

4. 转义符号
   转义符号：通过在正则中有特殊功能或者意义前加'\',让这个正则符号变成普通符号
   注意：除了^放在[]开头，和-放在两个字符之间以外，其他单独的特殊符号，在[]没有特殊功能都是表示字符本身
   只要有歧义的时候，就加''

   re_str = r'\d\d\.\d\d'
   print(re.fullmatch(re_str, '34.34'))
   

   re_str = r'\^\d\d\d'
   print(re.fullmatch(re_str, '^344'))
   

   re_str = r'\\d\d\d\d'
   print(re.fullmatch(re_str, '\d344'))
   

   re_str = r'\d\d[.]\d\d'
   print(re.fullmatch(re_str, '34.64'))
   

   ^在[]中不是在开头就没有特殊意义

   re_str = r'\d\d[a^-]\d\d'
   print(re.fullmatch(re_str, '34^64'))
   

   -在[]中只要不是放在两个字符之间都表示-本身

   re_str = r'\d\d[-]\d\d'
   print(re.fullmatch(re_str, '34-64'))
   re_str = r'\d\d[-a]\d\d'
   print(re.fullmatch(re_str, '34-64'))
   

   []里有字符1，-，a，]

   re_str = r'\d\d[1\-a\]]\d\d'
   print(re.fullmatch(re_str, '34]64'))
   print(re.fullmatch(re_str, '34-64'))
   

5. 匹配次数
   1）*(匹配0次或多次)

   字符*  --  指定的字符出现0次或者多次
   a*  --  字符a匹配0次或者多次
   \d*  --  数字匹配0次或者多次
   [a-z]* -- 小写字母匹配0次或者多次
   

   re_str = r'a*bc'
   print(re.fullmatch(re_str, 'bc'))
   print(re.fullmatch(re_str, 'abc'))
   print(re.fullmatch(re_str, 'aabc'))
   

   2）+(匹配1次或者多次)
   匹配一个字符串开头是a,结束是b,中间至少一个数字

   re_str = r'a\d+b'
   print(re.fullmatch(re_str, 'a89b'))
   re_str = r'a\d\d*b'
   print(re.fullmatch(re_str, 'a69b'))
   

   3）?(0次或1次)
   练习：写一个正则表达式，能够匹配一个整数字符串
   283 -73、+7,67, 9

   re_str = r'[+-]?\d+'
   print(re.fullmatch(re_str, '-24'))
   print(re.fullmatch(re_str, '+24'))
   print(re.fullmatch(re_str, '4'))
   print(re.fullmatch(re_str, '-246986654'))
   

   4）{}

   {N}  -  匹配N次
   {M,N} - 匹配至少M次，最多N次
   {M,}  -  匹配至少M次
   {,N}  -  匹配最多N次
   * == {0,}
   + == {1,}
   ? == {0,1}
   

   re_str = r'\d{4}'
   print(re.fullmatch(re_str, '8273'))
   

   re_str = r'\d{2,4}'
   print(re.fullmatch(re_str, '889'))
   
   re_str = r'[xyz]{,3}'
   print(re.fullmatch(re_str, 'xy'))
   

   练习:写一个正则表达式判断密码是否符号要求：密码由数字和字母组成，并第一个字符是大写字母，长度是6-12位

   re_str = r'[A-Z][a-zA-Z\d]{5,11}'
   print(re.fullmatch(re_str, 'A27ggh342h'))
   

   5）非贪婪（~）

   1)贪婪 - 匹配次数不确定的时候尽可能多的匹配 （上面次数不确定的符号都是贪婪的）
   2)非贪婪 - 匹配次数不确定的时候尽可能少的匹配 (上面次数不确定的符号后面加?就会变成非贪婪)
   *? - 0次或多次, 尽可能少
   +? - 1次或多次, 尽可能少
   ?? - 0次或1次, 尽可能少
   {N,M}?
   {M,}?
   {,N}?
   

   re_str = r'a+?'
   print(re.search(re_str, 'A2aaaaaa2h'))
   
   re_str = r'a.+?b'
   print(re.search(re_str, 'a23bgshjsb===='))
   
   re_str = r'a.*b'
   print(re.search(re_str, 'a23bhksdb===='))
   

6. 分支和分组
   1）|（分支）

   正则1|正则2  --  先用正则1进行匹配，如果匹配失败再用正则2匹配(正则1和正则2中只要有一个匹配成功就成功，两个失败了才会失败)
   

   注意：如果正则1匹配成功了，不会再使用正则2去匹配

   匹配一个字符串，开头是abc或者xyz，后面是123
   'abc123' ,'xyz123'
   ​```python
   re_str = r'abc|xyz'
   print(re.fullmatch(re_str, 'abc'))
   

   re_str = r'\d{3}|xyz[a-zA-Z]{4}|\+{3}'
   print(re.fullmatch(re_str, '+++'))
   

   2）() (分组)

   将部分正则作为一个整体
   1.整体区分
   (xxx|yyy)[A-Z]{2}[a-z]{2}\d{2}
   2.整体操作
   (\d{2}[a-zA-Z{2}]){3}
   3.整体重复
   \M  --  重复前面第M个匹配到的内容
   

   匹配一个字符串是xxx123，yyy123

   re_str = r'(xxx|yyy)123'
   print(re.fullmatch(re_str, 'xxx123'))
   print(re.fullmatch(re_str, 'yyy123'))
   

   re_str = r'(\d{2}[a-zA-Z]{2}){3}'
   print(re.fullmatch(re_str, '12AB34GH24JK'))
   

   89sdf89,67sfd67

   re_str = r'(\d\d\d)abc\1'
   print(re.fullmatch(re_str, '123abc123'))
   re_str = r'(\d{3})([a-z]{2})\2\1\2'
   print(re.fullmatch(re_str, '123asas123as'))
   

2. 正则表达式-方法（regular）

from re import *

1. (了解)compile(正则表达式) -- 创建正则表达式对象

re_str = r'\d{3}'
re_obj = compile(re_str)
re_obj.fullmatch('234')

2. fullmatch -- 完全匹配

fullmatch(正则表达式，字符串)  --  让正则和字符串完全匹配;匹配失败返回None，匹配成功返回匹配对象

对整个字符串进行检查的时候使用，比如判断账号、密码是否合法；手机号、邮箱是否合法等

result = fullmatch(r'\d{3}[a-z]{2}[A-Z]{3}', '234asGHD')
print(result)

3. match -- 匹配字符串开头

match(正则表达式, 字符串)  --  让正则和字符串开头匹配；匹配失败返回None，匹配成功返回匹配对象

result = match(r'\d{3}', '3495hsjs02-3')
print(result)

4. search -- 字符串查找

search(正则表达式, 字符串)  --  在字符串中找到第一个和正则表达式匹配的子串；没有匹配到就返回None，否则返回匹配对象

result = search(r'a(\d{3})([A-Z]{2})', 'a345AS')
print(result)   # <_sre.SRE_Match object; span=(0, 6), match='a345AS'>

通过匹配对象能获取到以下内容

# a.匹配结果
print(result.group())   # 获取整个正则表达式匹配到的结果  a345AS
print(result.group(1))  # 获取第一个分组匹配到的结果   345
print(result.group(2))  # 获取第二个分组匹配到的结果   AS

# b.匹配返回（被匹配到的内容在原字符串中的范围-（开始下标, 结束下标））
print(result.span())    #  (0, 6)
print(result.start())    # 0
print(result.end())    # 6

# c.获取原字符串
print(result.string)  # a345AS

5. split -- 字符串切割

split(正则表达式, 字符串, 切割次数)  --  将字符串按照满足正则表达式的子串进行切割；返回的是一个列表，列表中是被切开的子串
切割次数  --  不传参就全切

# ['alfhuiwe', 'h', 'ugy3fr23GHJFTY87GHJG8g6f']
print(split(r'\d+|[A-Z]+', 'alfhuiwe7384h2ugy3fr23GHJFTY87GHJG8g6f', 2))

6. sub -- 字符串替换

sub(正则表达式,新字符串,原字符串,替换次数)  --  将原字符串中满足正则表达式的子串替换成新字符串
替换次数  --  不传参就全部替换

print(sub(r'\d+', '*','aaisafyr34359yh47fus7srer98'))     # aaisafyr*yh*fus*srer*

7. findall -- 查找所有

findall(正则表达式，字符串)  --  在字符串中查找所有满足正则表达式的子串，以列表的形式返回

# 有一个分组，只取分组匹配到的内容
print(findall(r'\d+a', 'afu78efha6asajf78fiwe98aeu3od'))  # ['6a', '98a']
# 有一个分组，只取分组匹配到的内容
print(findall(r'(\d+)a', 'afu78efha6asajf78fiwe98aeu3od'))    # ['6', '98']

print(findall(r'(\d+)([a-z]{2})', 'afu78efha6asajf78fiwe98aeu3od'))  # [('78', 'ef'), ('6', 'as'), ('78', 'fi'), ('98', 'ae'), ('3', 'od')]

注意：使用findall的时候，如果有分组想要取整个正则匹配的结果是取不到的

print(findall(r'(\d[a-z]){3}\+', ''))   # []

8. finditer -- 查找所有

finditer(正则表达式, 字符串)  --  在字符串中查找所有满足正则表达式的子串：返回一个迭代器，元素是每个子串对应的匹配结对象

result = finditer(r'(\d[a-z]){3}\+', 'ahjs8a2a8j+胡士大夫9m2s0j+接收到sd8p+ss===')
print(result)   # <callable_iterator object at 0x0056E190>
for x in result:
    print(x.group(), x.group(1))    # 8a2a8j+ 8j     9m2s0j+ 0j

教师资料-字符串和正则表达式

使用正则表达式

正则表达式相关知识

在编写处理字符串的程序或网页时，经常会有查找符合某些复杂规则的字符串的需要，正则表达式就是用于描述这些规则的工具，换句话说正则表达式是一种工具，它定义了字符串的匹配模式（如何检查一个字符串是否有跟某种模式匹配的部分或者从一个字符串中将与模式匹配的部分提取出来或者替换掉）。如果你在Windows操作系统中使用过文件查找并且在指定文件名时使用过通配符（*和?），那么正则表达式也是与之类似的用来进行文本匹配的工具，只不过比起通配符正则表达式更强大，它能更精确地描述你的需求（当然你付出的代价是书写一个正则表达式比打出一个通配符要复杂得多，要知道任何给你带来好处的东西都是有代价的，就如同学习一门编程语言一样），比如你可以编写一个正则表达式，用来查找所有以0开头，后面跟着2-3个数字，然后是一个连字号“-”，最后是7或8位数字的字符串（像028-12345678或0813-7654321），这不就是国内的座机号码吗。最初计算机是为了做数学运算而诞生的，处理的信息基本上都是数值，而今天我们在日常工作中处理的信息基本上都是文本数据，我们希望计算机能够识别和处理符合某些模式的文本，正则表达式就显得非常重要了。今天几乎所有的编程语言都提供了对正则表达式操作的支持，Python通过标准库中的re模块来支持正则表达式操作。

我们可以考虑下面一个问题：我们从某个地方（可能是一个文本文件，也可能是网络上的一则新闻）获得了一个字符串，希望在字符串中找出手机号和座机号。当然我们可以设定手机号是11位的数字（注意并不是随机的11位数字，因为你没有见过“25012345678”这样的手机号吧）而座机号跟上一段中描述的模式相同，如果不使用正则表达式要完成这个任务就会很麻烦。

关于正则表达式的相关知识，大家可以阅读一篇非常有名的博客叫《正则表达式30分钟入门教程》，读完这篇文章后你就可以看懂下面的表格，这是我们对正则表达式中的一些基本符号进行的扼要总结。

说明：如果需要匹配的字符是正则表达式中的特殊字符，那么可以使用\进行转义处理，例如想匹配小数点可以写成\.就可以了，因为直接写.会匹配任意字符；同理，想匹配圆括号必须写成\(和\)，否则圆括号被视为正则表达式中的分组。

Python对正则表达式的支持

Python提供了re模块来支持正则表达式相关操作，下面是re模块中的核心函数。

说明：上面提到的re模块中的这些函数，实际开发中也可以用正则表达式对象的方法替代对这些函数的使用，如果一个正则表达式需要重复的使用，那么先通过compile函数编译正则表达式并创建出正则表达式对象无疑是更为明智的选择。

下面我们通过一系列的例子来告诉大家在Python中如何使用正则表达式。

例子1：验证输入用户名和QQ号是否有效并给出对应的提示信息。

"""

验证输入用户名和QQ号是否有效并给出对应的提示信息

要求：
用户名必须由字母、数字或下划线构成且长度在6~20个字符之间
QQ号是5~12的数字且首位不能为0

"""

import re


def main():
    username = input('请输入用户名: ')
    qq = input('请输入QQ号: ')
    # match函数的第一个参数是正则表达式字符串或正则表达式对象
    # 第二个参数是要跟正则表达式做匹配的字符串对象
    m1 = re.match(r'^[0-9a-zA-Z_]{6,20}$', username)
    if not m1:
        print('请输入有效的用户名.')
    m2 = re.match(r'^[1-9]\d{4,11}$', qq)
    if not m2:
        print('请输入有效的QQ号.')
    if m1 and m2:
        print('你输入的信息是有效的!')


if __name__ == '__main__':
    main()

提示：上面在书写正则表达式时使用了“原始字符串”的写法（在字符串前面加上了r），所谓“原始字符串”就是字符串中的每个字符都是它原始的意义，说得更直接一点就是字符串中没有所谓的转义字符啦。因为正则表达式中有很多元字符和需要进行转义的地方，如果不使用原始字符串就需要将反斜杠写作\\，例如表示数字的\d得书写成\\d，这样不仅写起来不方便，阅读的时候也会很吃力。

例子2：从一段文字中提取出国内手机号码。

下面这张图是截止到2017年底，国内三家运营商推出的手机号段。

import re


def main():
    # 创建正则表达式对象 使用了前瞻和回顾来保证手机号前后不应该出现数字
    pattern = re.compile(r'(?<=\D)1[34578]\d{9}(?=\D)')
    sentence = '''
    重要的事情说8130123456789遍，我的手机号是13512346789这个靓号，
    不是15600998765，也是110或119，王大锤的手机号才是15600998765。
    '''
    # 查找所有匹配并保存到一个列表中
    mylist = re.findall(pattern, sentence)
    print(mylist)
    print('--------华丽的分隔线--------')
    # 通过迭代器取出匹配对象并获得匹配的内容
    for temp in pattern.finditer(sentence):
        print(temp.group())
    print('--------华丽的分隔线--------')
    # 通过search函数指定搜索位置找出所有匹配
    m = pattern.search(sentence)
    while m:
        print(m.group())
        m = pattern.search(sentence, m.end())


if __name__ == '__main__':
    main()

说明：上面匹配国内手机号的正则表达式并不够好，因为像14开头的号码只有145或147，而上面的正则表达式并没有考虑这种情况，要匹配国内手机号，更好的正则表达式的写法是：(?<=\D)(1[38]\d{9}|14[57]\d{8}|15[0-35-9]\d{8}|17[678]\d{8})(?=\D)，国内最近好像有19和16开头的手机号了，但是这个暂时不在我们考虑之列。

例子3：替换字符串中的不良内容

import re


def main():
    sentence = '你丫是傻叉吗? 我操你大爷的. Fuck you.'
    purified = re.sub('[操肏艹草曹]|fuck|shit|傻[比屄逼叉缺吊屌]|煞笔',
                      '*', sentence, flags=re.IGNORECASE)
    print(purified)  # 你丫是*吗? 我*你大爷的. * you.


if __name__ == '__main__':
    main()

说明：re模块的正则表达式相关函数中都有一个flags参数，它代表了正则表达式的匹配标记，可以通过该标记来指定匹配时是否忽略大小写、是否进行多行匹配、是否显示调试信息等。如果需要为flags参数指定多个值，可以使用按位或运算符进行叠加，如flags=re.I | re.M。

例子4：拆分长字符串

import re


def main():
    poem = '窗前明月光，疑是地上霜。举头望明月，低头思故乡。'
    sentence_list = re.split(r'[，。, .]', poem)
    while '' in sentence_list:
        sentence_list.remove('')
    print(sentence_list)  # ['窗前明月光', '疑是地上霜', '举头望明月', '低头思故乡']


if __name__ == '__main__':
    main()

后话

如果要从事爬虫类应用的开发，那么正则表达式一定是一个非常好的助手，因为它可以帮助我们迅速的从网页代码中发现某种我们指定的模式并提取出我们需要的信息，当然对于初学者来收，要编写一个正确的适当的正则表达式可能并不是一件容易的事情（当然有些常用的正则表达式可以直接在网上找找），所以实际开发爬虫应用的时候，有很多人会选择Beautiful Soup或Lxml来进行匹配和信息的提取，前者简单方便但是性能较差，后者既好用性能也好，但是安装稍嫌麻烦，这些内容我们会在后期的爬虫专题中为大家介绍。