常用模块——re模块
目录
认识模块
什么是模块？
常见的场景：一个模块就是一个包含了python定义和声明的文件，文件名就是模块名字加上.py的后缀。
但其实import加载的模块分为四个通用类别：
1 使用python编写的代码（.py文件）
2 已被编译为共享库或DLL的C或C++扩展
3 包好一组模块的包
4 使用C编写并链接到python解释器的内置模块
为何要使用模块？
如果你退出python解释器然后重新进入，那么你之前定义的函数或者变量都将丢失，因此我们通常将程序写到文件中以便永久保存下来，需要时就通过python test.py方式去执行，此时test.py被称为脚本script。
随着程序的发展，功能越来越多，为了方便管理，我们通常将程序分成一个个的文件，这样做程序的结构更清晰，方便管理。这时我们不仅仅可以把这些文件当做脚本去执行，还可以把他们当做模块来导入到其他的模块中，实现了功能的重复利用
re模块
讲正题之前我们先来看一个例子：https://reg.jd.com/reg/person?ReturnUrl=https%3A//www.jd.com/
这是京东的注册页面，打开页面我们就看到这些要求输入个人信息的提示。
假如我们随意的在手机号码这一栏输入一个11111111111，它会提示我们格式有误。
引入
这个功能是怎么实现的呢？
假如现在你用python写一段代码，类似：
phone_number = input('please input your phone number ： ')
你怎么判断这个phone_number是合法的呢？
根据手机号码一共11位并且是只以13、14、15、18开头的数字这些特点，我们用python写了如下代码：
判断手机号是否合法
纯python代码实现
phone = input('请输入手机号').strip()
def valid_phone():
if len(phone) == 11:
# 1. 验证是不是纯数字
if phone.isdigit():
# 2. 验证手机是13 15 17 18 19
if phone.startswith('13')
or phone.startswith('15')
or phone.startswith('17')
or phone.startswith('18')
or phone.startswith('19'):
print('手机号输入正确')
else:
print('格式不正确')
else:
print('输入的字符必须全是数字')
else:
print('手机号必须输入11位')
逆向思路
phone = input('请输入手机号').strip()
def valid(phone):
if len(phone) != 11:
print('手机号尾数必须是11位')
return
if not phone.isdigit():
print('手机号必须是纯数字')
return
if not phone.startswith('13'):
print('手机号不正确')
return
'''代码走到这个位置，说明手机号格式一定是正确的'''
'''在这里写正常的逻辑代码'''
print('手机号输入正确')
valid(phone)
python结合正则实现
import re
phone_number = input('please input your phone number: ')
if re.match('^(13|14|15|18)[0-9]{9}$', phone_number):
print('是合法的手机号码')
else:
print('不是合法的手机号码')
最后一种方法的代码是不是非常简单。正则表达式不仅在python领域，在整个编程届都占有举足轻重的地位。
正则表达式和re模块
不管以后你是不是去做python开发，只要你是一个程序员就应该了解正则表达式的基本使用。如果未来你要在爬虫领域发展，你就更应该好好学习这方面的知识。
但是你要知道，re模块本质上和正则表达式没有一毛钱的关系。re模块和正则表达式的关系 类似于 time模块和时间的关系
你没有学习python之前，也不知道有一个time模块，但是你已经认识时间了 12:30就表示中午十二点半（这个时间可好，一般这会儿就该下课了）。
时间有自己的格式，年月日时分秒，12个月，365天......已经成为了一种规则。你也早就牢记于心了。time模块只不过是python提供给我们的可以方便我们操作时间的一个工具而已
正则表达式本身也和python没有什么关系，就是匹配字符串内容的一种规则。
官方定义：正则表达式是对字符串操作的一种逻辑公式，就是用事先定义好的一些特定字符、及这些特定字符的组合，组成一个“规则字符串”，这个“规则字符串”用来表达对字符串的一种过滤逻辑。
正则表达式
正则表达式它跟任何一门语言都没有关系，它是一门独立的语言!!!
正则表达式是利用一些特殊符号来筛选出我们想要的数据
一说规则我已经知道你很晕了，现在就让我们先来看一些实际的应用。在线测试工具 http://tool.chinaz.com/regex/
首先你要知道的是，谈到正则，就只和字符串相关了。在我给你提供的工具中，你输入的每一个字都是一个字符串。其次，如果在一个位置的一个值，不会出现什么变化，那么是不需要规则的。
比如你要用"1"去匹配"1"，或者用"2"去匹配"2"，直接就可以匹配上。这连python的字符串操作都可以轻松做到。那么在之后我们更多要考虑的是在同一个位置上可以出现的字符的范围。
字符组
字符组 ： [字符组] 在同一个位置可能出现的各种字符组成了一个字符组，在正则表达式中用[]表示 字符分为很多类，比如数字、字母、标点等等。 假如你现在要求一个位置"只能出现一个数字",那么这个位置上的字符只能是0、1、2...9这10个数之一。
'''字符组默认匹配方式是挨个挨个匹配'''
| 正则 | 待匹配字符 | 匹配结果 | 说明 |
|---|---|---|---|
| [0123456789] | 8 | True | 在一个字符组里枚举合法的所有字符，字符组里的任意一个字符和"待匹配字符"相同都视为可以匹配 |
| [0123456789] | a | False | 由于字符组中没有"a"字符，所以不能匹配 |
| [0-9] | 6 | True | 也可以用-表示范围,[0-9]就和[0123456789]是一个意思 |
| [a-z] | s | True | 同样的如果要匹配所有的小写字母，直接用[a-z]就可以表示 |
| [A-Z] | B | True | [A-Z]就表示所有的大写字母 |
| [0-9a-fA-F] | y | True | 可以匹配数字，大小写形式的a～f，用来验证十六进制字符 |
ps:字符组内所有的数据默认都是或的关系
特殊字符
'''特殊符号默认匹配方式是挨个挨个匹配'''
| 元字符 | 匹配内容 |
|---|---|
| . | 匹配除换行符以外的任意字符 |
| \w | 匹配数字、字母、下划线 |
| \W | 匹配非数字、非字母、非下划线 |
| \d | 匹配数字 |
| \D | 匹配非数字 |
| \s | 匹配任意的空白符 |
| \S | 匹配非空白符 |
| \n | 匹配一个换行符 |
| \t | 匹配一个制表符 |
| \b | 匹配一个单词的结尾 |
| ^ | 匹配字符串的开头 |
| $ | 匹配字符串的结尾 |
| a|b | 匹配a或者b(管道符的意思是或) |
| () | 给正则表达式分组 不影响表达式的匹配功能 |
| [] | 字符组 内部填写的内容默认都是或的关系 |
| [^] | 取反操作 匹配除了字符组里面的其他所有字符 |
^、$两者组合使用可以非常精确的限制匹配的内容
注意上尖号在中括号内和不在中括号意思完全不同
量词
| 量词 | 用法说明 |
|---|---|
| * | 匹配零次或多次，默认是多次(无穷次) |
| + | 匹配一次或多次，默认是多次(无穷次) |
| ? | 匹配零次或一次，作为量词意义不大主要用于非贪婪匹配 |
{n} |
重复n次 |
{n,} |
重复n次或更多次，默认是多次(无穷次) |
{n,m} |
重复n到m次，默认是m次 |
- 量词不能单独使用
- 量词只会影响前面的一个字符 (ab+ 只会影响b)
- 量词一定配合表达式使用
正则练习
. ^ $
| 正则 | 待匹配字符 | 匹配结果 | 说明 |
|---|---|---|---|
| 海. | 海燕海娇海东 | 海燕海娇海东 | 匹配所有"海."的字符 |
| ^海. | 海燕海娇海东 | 海燕 | 只从开头匹配"海." |
| 海.$ | 海燕海娇海东 | 海东 | 只匹配结尾的"海.$" |
* + ?
| 正则 | 待匹配字符 | 匹配结果 | 说明 |
|---|---|---|---|
| 李.? | 李杰和李莲英和李二棍子 | 李杰 李莲 李二 |
?表示重复零次或一次，即只匹配"李"后面一个任意字符 |
| 李.* | 李杰和李莲英和李二棍子 | 李杰和李莲英和李二棍子 | *表示重复零次或多次，即匹配"李"后面0或多个任意字符 |
| 李.+ | 李杰和李莲英和李二棍子 | 李杰和李莲英和李二棍子 | +表示重复一次或多次，即只匹配"李"后面1个或多个任意字符 |
| 李. | 李杰和李莲英和李二棍子 | 李杰和 李莲英 李二棍 |
{1,2}匹配1到2次任意字符 |
注意：前面的*,+,?等都是贪婪匹配，也就是尽可能匹配，后面加?号使其变成惰性匹配
| 正则 | 待匹配字符 | 匹配结果 | 说明 |
|---|---|---|---|
| 李.*? | 李杰和李莲英和李二棍子 | 李 李 李 |
惰性匹配 |
字符集［］［^］
| 正则 | 待匹配字符 | 匹配结果 | 说明 |
|---|---|---|---|
| 李[杰莲英二棍子]* | 李杰和李莲英和李二棍子 | 李杰 李莲英 李二棍子 |
表示匹配"李"字后面[杰莲英二棍子]的字符任意次 |
| 李[^和]* | 李杰和李莲英和李二棍子 | 李杰 李莲英 李二棍子 |
表示匹配一个不是"和"的字符任意次 |
| [\d] | 456bdha3 | 456bdha3 4 5 6 3 |
表示匹配任意一个数字，匹配到4个结果 |
| [\d]+ | 456bdha3 | 456bdha3 456 | |
| 3 | 表示匹配任意个数字，匹配到2个结果 |
分组 ()与 或 ｜［^］
身份证号码是一个长度为15或18个字符的字符串，如果是15位则全部由数字组成，首位不能为0；如果是18位，则前17位全部是数字，末位可能是数字或x，下面我们尝试用正则来表示：
| 正则 | 待匹配字符 | 匹配结果 | 说明 |
|---|---|---|---|
| ^[1-9]\d{13,16}[0-9x]$ | 110101198001017032 | 110101198001017032 | 表示可以匹配一个正确的身份证号 |
| ^[1-9]\d{13,16}[0-9x]$ | 1101011980010170 | 1101011980010170 | 表示也可以匹配这串数字，但这并不是一个正确的身份证号码，它是一个16位的数字 |
| ^[1-9]\d{14}(\d{2}[0-9x])?$ | 1101011980010170 | False | 1.现在不会匹配错误的身份证号了,2.()表示分组，将\d{2}[0-9x]分成一组，就可以整体约束他们出现的次数为0-1次 |
| ^([1-9]\d{16}[0-9x] | [1-9]\d{14})$ | 110105199812067023 | 110105199812067023 |
转义符 \
在正则表达式中，有很多有特殊意义的是元字符，比如\n和\s等，如果要在正则中匹配正常的"\n"而不是"换行符"就需要对""进行转义，变成'\'。
在python中，无论是正则表达式，还是待匹配的内容，都是以字符串的形式出现的，在字符串中\也有特殊的含义，本身还需要转义。所以如果匹配一次"\n",字符串中要写成'\n'，那么正则里就要写成"\\n",这样就太麻烦了。这个时候我们就用到了r'\n'这个概念，此时的正则是r'\n'就可以了。
| 正则 | 待匹配字符 | 匹配结果 | 说明 |
|---|---|---|---|
| \n | \n | False | 因为在正则表达式中\是有特殊意义的字符，所以要匹配\n本身，用表达式\n无法匹配 |
| \n | \n | True | 转义\之后变成\，即可匹配 |
| "\\n" | '\n' | True | 如果在python中，字符串中的''也需要转义，所以每一个字符串''又需要转义一次 |
| r'\n' | r'\n' | True | 在字符串之前加r，让整个字符串不转义 |
贪婪匹配
贪婪匹配：在满足匹配时，匹配尽可能长的字符串，默认情况下，采用贪婪匹配
| 正则 | 待匹配字符 | 匹配结果 | 说明 |
|---|---|---|---|
| <.*> | <script>...<script> | <script>...<script> | 默认为贪婪匹配模式，会匹配尽量长的字符串 |
| <.*?> | r'\d' | <script> <script> |
加上？为将贪婪匹配模式转为非贪婪匹配模式，会匹配尽量短的字符串 |
.*?的用法
. 是任意字符
* 是取 0 至 无限长度
? 是非贪婪模式。
何在一起就是 取尽量少的任意字符，一般不会这么单独写，他大多用在：
.*?x
就是取前面任意长度的字符，直到一个x出现
正则表达式实战
能够写出简单的正则 能够大致看懂复杂的正则
1.编写校验用户身份证号的正则
^[1-9]\d{13,16}[0-9x]$
^[1-9]\d{14}(\d{2}[0-9x])?$
^([1-9]\d{16}[0-9x]|[1-9]\d{14})$
2.编写校验邮箱的正则
\w[-\w.+]*@([A-Za-z0-9][-A-Za-z0-9]+\.)+[A-Za-z]{2,14}
3.编写校验用户手机号的正则(座机、移动)
移动:
0?(13|14|15|17|18|19)[0-9]{9}
^(13|14|15|18)[0-9]{9}$
座机：
[0-9-()（）]{7,18}
4.编写校验用户qq号的正则
[1-9]([0-9]{5,11})
5.身份证号的正则
^[1-9]\d{13,16}[0-9x]$
'''很多时候 很多问题 前人已经弄好了 你只需要花点时间找一找就可以'''
正则表达式模糊匹配和精准匹配
正则表达式是范围匹配：
待匹配的文本
haohgakevinagkevinhiahgkevin
待使用的正则(贪婪匹配：有几个就匹配几个)
kevin
匹配的结果：
kevin
kevin
kevin 3条
在正则表达式中精准匹配：
1.待匹配的文本
haohgakevinagkevinhiahgkevin
待使用的正则
^kevin$
匹配的结果：
没有结果
2.待匹配的文本
kevin
待使用的正则
^kevin$
匹配的结果：
kevin 1条
3.待匹配的文本
kevinkevin
待使用的正则
^kevin$
匹配的结果：
没有结果
re模块下的常用方法
import re
findall()、search()、match()使用
1.findall()
findall(pattern, string, flags=0)
查找所有符合正则表达式要求的数据
如果匹配到了，就返回匹配到的结果，是列表形式
匹配不到，返回[]，并没有报错
r1 = re.findall('a', 'keain jack toay')
print(r1) # ['a', 'a', 'a']
r2 = re.findall('bbb', 'keain jack toay')
print(r2) # []
r3 = re.findall('^a', 'arertewtre')
print(r3) # ['a']
r4 = re.findall('a$', 'arertewtrea')
print(r4) # ['a']
r5 = re.findall('^a$', 'aaaa')
print(r5) # []
r6 = re.findall('^a$', 'a')
print(r6) # ['a']
2.search()
search(pattern, string, flags=0)
匹配到第一个符合条件的数据就立刻结束
函数会在字符串内查找模式匹配
只要找到第一个符合条件的数据就返回一个包含匹配信息的对象,该对象可以通过调用group()方法得到匹配的字符串
如果字符串没有匹配，则返回None。
r1 = re.search('a', 'jason apple eva')
print(r1) # <_sre.SRE_Match object; span=(1, 2), match='a'>
print(r1.group()) # a
r2 = re.search('aa', 'kein jaack toay')
print(r2) # <_sre.SRE_Match object; span=(6, 8), match='aa'>
print(r2.group()) # aa
r3 = re.search('bbb', 'keain jack toay')
print(r3) # None
# print(r3.group()) # 不能使用，会报错
# 想要直接使用group,可以用以下方法：
r4 = re.search('a', 'jason apple eva')
try:
print(r4.group())
except Exception:
print('没有匹配到')
# 输出结果是：a
r5 = re.search('^a', 'jason apple eva')
if r5:
print(r5.group())
else:
print('没有匹配')
# 输出结果是：没有匹配
3.match()
match(pattern, string, flags=0)
同search,不过是在字符串开始处进行匹配
匹配开头符合条件的数据，一个就结束
如果不符合，后面就不用看了
r1 = re.match('k', 'keain jack toay')
print(r1) # <_sre.SRE_Match object; span=(0, 1), match='k'>
print(r1.group()) # k
r2 = re.match('a', 'keain jack toay')
print(r2) # None
res=re.match('a', 'keain jack toay')
try:
print(res.group())
except Exception:
print('没有匹配到')
print(123)
if res:
print(res.group())
else:
print('没有匹配')
分组
1.分组优先
'''
findall方法，分组优先展示 括号内正则表达式匹配到的内容(重点)
'''
res1 = re.findall('www.(baidu|oldboy).com', 'www.oldboy.com')
print(res1) # ['oldboy']
# 取消优先展示， 字符前面加上?:
res2 = re.findall('www.(?:baidu|oldboy).com', 'www.oldboy.com')
print(res2) # ['www.oldboy.com']
res3 = re.findall("^[1-9]\d{14}(\d{2}[0-9x])?$",'110105199812067023')
print(res3) # ['023']
'''无名分组和有名分组'''
2.无名分组
ret1 = re.search('^([1-9])(\d{14})(\d{2}[0-9x])?$','110105199812067023')
print(ret1.group()) # 110105199812067023
# 分组取值是按照索引取值，索引从1开始
print(ret1.group(1)) # 1
print(ret1.group(2)) # 10105199812067
print(ret1.group(3)) # 023
ret2 = re.match('^([1-9])(\d{14})(\d{2}[0-9x])?$','110105199812067023')
print(ret2.group(3)) # 023
3.分组别名：?P<名字>
ret3 = re.search('^[1-9](?P<name>\d{14})(?P<xxx>\d{2}[0-9x])?$','110105199812067023')
print(ret3.group()) # 110105199812067023
print(ret3.group(1)) # 10105199812067
print(ret3.group(2)) # 023
print(ret3.group('name')) # 10105199812067
print(ret3.group('xxx')) # 023
# 既可以使用索引，也可以使用别名来展示
ret4 = re.search('www.(?P<content>baidu|oldboy)(?P<hei>.com)', 'www.oldboy.com')
print(ret4.group()) # www.oldboy.com
print(ret4.group(0)) # www.oldboy.com
print(ret4.group(1)) # oldboy
print(ret4.group(2)) # .com
print(ret4.group('content')) # oldboy
print(ret4.group('hei')) # .com
练习
1.爬取红牛公司官网数据
网络爬虫:通过编写代码模拟浏览器发送请求获取数据并按照自己指定的要求筛选出想要的数据
练习:利用正则表达式筛选出红牛所有的分公司数据并打印或保存
公司名称:
公司地址:
公司邮编:
公司电话:
import re
with open(r'a.txt', 'r', encoding='utf-8') as f:
data = f.read() # 文件数据比较小，可以直接全部读出
'''
正则表达式中：<h2>.*</h2>,这两个符号中间的都需要,用到.*，这样会输出<h2>红牛杭州分公司</h2>，
想要优先展示，可以使用(.*),量词都是贪婪匹配
想要非贪婪匹配，可以使用(.*?)
'''
# 名称
name_list = re.findall('<h2>(.*?)</h2>', data)
# print(name_list)
# 地址
address_list = re.findall("<p class='mapIco'>(.*?)</p>", data)
# print(address_list)
# 邮箱
email_list = re.findall("<p class='mailIco'>(.*?)</p>", data)
# print(email_list)
# 电话
phone_list = re.findall("<p class='telIco'>(.*?)</p>", data)
# print(phone_list)
# for i in range(len(name_list)):
# print("""
# 公司名称：%s
# 公司地址：%s
# 公司邮箱：%s
# 公司电话：%s
# """ % (name_list[i], address_list[i], email_list[i], phone_list[i]))
res=zip(name_list, address_list, email_list, phone_list)
# print(list(res))
# ret = list(res)
for t in res:
print("""
公司名称：%s
公司地址：%s
公司邮箱：%s
公司电话：%s
""" % (t[0], t[1], t[2], t[3]))
'''把数据写到Excel中(后续学习)'''
2.链家网
import re
with open(r'b.txt', 'r', encoding='utf-8') as f:
data = f.read()
# 名字
house_name = re.findall('data-strategy-info=.*>(.*?)</a>', data)
# 具体地址
address_list = re.findall('" data-other-action="strategy_info=.*>(.*?)</a>', data)
# 面积是
area_list = re.findall('<span>建面 (.*?)</span>', data)
area_list.insert(7, '/㎡')
# 特点：char
char = re.findall('<div class="resblock-tag">\n\s*<span>(.*?)</span>\n\s*<span>(.*?)</span>\n\s*<span>(.*?)</span>\n\s*<span>(.*?)</span>', data)
# 均价
average_price = re.findall('<span class="number">(.*?)</span>', data)
# 总价
total_price = re.findall('<div class="second">(.*?)</div>', data)
res = zip(house_name, address_list, area_list, char, average_price, total_price)
for t in res:
print("""
小区名称：%s
具体地址：%s
房子面积：%s
房子优势：%s
房子均价：%s
全房总价：%s
""" % (t[0], t[1], t[2], t[3], t[4], t[5]))
3.豆瓣电影
import re
with open(r'c.txt', 'r', encoding='utf-8') as f:
data = f.read()
# 电影名称
movie_name = re.findall('alt="(.*?)" class=""/>', data)
# print(movie_name) # 10个
# 上映时间
time_list = re.findall('<p class="pl">(.*?)/', data)
# print(time_list) # 10个
# 评分
# <span class="rating_nums">9.7</span>
grade = re.findall('<span class="rating_nums">(.*?)</span>', data)
# print(grade) # 10
# 评价人数
# <span class="pl">(22526人评价)</span>
# evaluator_number = re.findall('<span class="pl">(.*?)</span>', data)
evaluator_number = re.findall('<span class="pl">.(.*?).{3}</span>', data)
# print(evaluator_number)
res = zip(movie_name, time_list, grade, evaluator_number)
for i in res:
print("""
电影名称：%s
上映时间：%s
电影评分：%s
评价人数：%s
""" % (i[0], i[1], i[2], i[3]))
