re模块的介绍_re 模块

1：正则表达式

• 正则表达式是对字符串操作的一种逻辑公式，就是用事先定义好的一些特定字符、及这些特定字符的组合，组成一个“规则字符串”，这个“规则字符串”用来表达对字符串的一种过滤逻辑
• 可是说使用一组字符串来对另一组字符串来进行杀筛选和过滤的作用
• 可以把正则表的式比作一个筛子

2：正则表达式的用途

• 爬虫
• 表达验证

3：✨re模块的常用方法

3.1普通字符

• 字母、数字、汉字、下划线、以及没有特殊定义的符号，都是"普通字符"。正则
  表达式中的普通字符，在匹配的时候,只匹配与自身相同的一个字符。
• 普通字符可以理解为找一个和这个字符一摸一样的字符，没用别的功能了

3.2：match()函数

• 有三个参数：pattent, string, flags
  • pattent:正则表达式的模板，就像上面说的式筛子的筛字啊孔的大小
  • string:要匹配的数据，相当于要晒得谷物
  • flags:标志位，匹配的方式，比如是否区分大小写，是否匹配换行，re默认不换行，相当于要晒选谷物是要好看的还是难看的
• 返回值
  • 如果数据和表达式匹配成功了，则返回一个match对象，否则返回None

例子

import re

patten = 'python'
str1 = 'pytho and java'

res = re.match(patten, str).group()
if res:
	print(res)
else:
	print('没有匹配到！')
1
2
3
4
5
6
7
8
9
10

注意：

• match()函数的返回类型是一个match对象，要想显示这个对象里面的内容可以使用group()方法
• group()：返回match对象的内容
• groups()：以元组的形式返回match对象的内容

3.3：元字符

• re模块使用了很多的元字符，用来表示一些特殊的含义或功能
  • 小数点（“.”）：可以匹配除了换行（\n）之外的任意一个字符
  • 逻辑或（“|”）：可以匹配任意两个字符如：a|b 既可以匹配a,也可以匹配b
    • 注意：match()函数的特点，是以最前面的字符开始匹配，若匹配成功则返回，匹配不成功则抛出异常。但是search()函数不是从第一个字符开始匹配的，所以match()函数和search()函数可以灵活使用
  • 方括号（”[]“）：可以匹配字符集中的一个字符如：[abc]2既可以匹配a2、b2也可以匹配c2
  • 取反操作（”[^]“）：对字符集取反操作，也就是上面子集的反操作。尖号必须放在方括号的最前面
  • ”-“：至操作1-5相当于：12345
  • 注意：在re中的元字符不是正表达式该有的逻辑，正则表达式的模板中出现了一些元字符，但是这些元字符不在正则表达式的逻辑中，要使用转义字符”\“来处理一下，因为在re中的元字符也可以使用这些字符如".=.”这个地方的”.“只是代表一个点，不具有匹配任意不换行字符的功能了

  3.4：预定义匹配字符集

  • 可以直接拿来用的字符集模板
  • 正则表达式中的一些表示方法，可以同时匹配某个预定义字符集中的任意一个字符。比如，表达式\d可以匹配任意一个数字。虽然可以匹配其中任意字符，但是只能是一个，不是多个

  预定义字符集总结

  预定义字符集	描述
  \d	可以匹配0-9中的任意一个数字，等效于[0123456789]、[0-9]
  \w	可以匹配任意一个字母、数字或下划线，等效于[a-zA-Z0-9_]
  \s	可以匹配空格，制表符或其他的空白
  \D	\d的反集，也就是除了数字不能匹配之外，别的字符都可以匹配
  \W	\d的反集，也就是除了字母、数字和下划线不能匹配之外，别的字符都可以匹配
  \S	\s的反集，也就是除了空格、制表符和其它的空白不能匹配之外，其余的字符都可以匹配

3.5：重复匹配

• 前面的表达式，无论是只能匹配一种字符的表达式，还是可以匹配多种字符其中任意一个的表达式，都只能匹配一次。但是有时候我们需要对某个字段进行重复匹配，例如手机号码13666666666，一般的新手可能会写成\d\d\d\d\d\d\d\d\d\d\d（注意，这不是一个恰当的表达式），不但写着费劲，看着也累，还不⼀定准确恰当。
  这种情况可以使用表达式再加上修饰匹配次数的特殊符号{}，可以不用重复书写表达式就可以重复匹配。例如

  [abcd][abcd]可以写成[abcd]{2}
  1

  重复匹配符号总结

  符号	描述
  {n}	表示重复n次。如：\b{3} = \b\b\b,a{3} = aaa
  {m,n}	表示至少重复m次,最多重复n次，m：下限，n：上限。比如：ab{1,3}可以匹配ab,abb还可以匹配abbb
  {m,}	表示至少重复m次。比如：a{2,}可以匹配aaa、aaaa还可以匹配aaaaaaaa
  {,n}	表示至少可以匹配n次
  *	可以匹配表达式0次到任意次，是用来表示数量的。和{0,}是等效的比如：^*b可以匹配b、^b还可以匹配^^^b
  +	可以匹配表达式1次到任意次，也是用来表示数量的，和”*“唯一的差别就是不能匹配到0次

3.6：位置匹配和非贪婪匹配

• 贪婪匹配

  • 以尽可能匹配的最长的结果返回，python默认的就是贪婪匹配

• 非贪婪匹配

  • 就是尽可能匹配最短的结果返回，在贪婪匹配的后面加一个？

开始和结尾

• ^：开始匹配的地方
• $：匹配结束的地方

4：爬虫的使用

前面的内容 + .*? + 后面的内容

5：re模块的常用方法

常见方法总结

5.1:compile()方法

• 是re模块的工厂方法，返回的是一个re的patten对象
• 用法：

import re
pat = re.compile(r'abc123', re.S)		# re.S标志位：意味着可以换行匹配
respones = pat.match('abc123').gloup()
print(response)
-----------------输出-------------------
'abc123456'
1
2
3
4
5
6

5.2:search()方法

• 在字符串中查找匹配的模板,也就是不是从第一个位置的字符串开始查找的，且只匹配一个字符串
• 用法：

import re
pat = re,search(r'abc123','defabc123')
print(pat.gloup())
----------输出----------------
abc123
1
2
3
4
5

5.3:match方法

• 和search()方法的作用是一样，唯一不不同的就是match方法是从第一个字符开始匹配的，如果第一个字符不符合要求就返回None，但是search方法是从整个字符串开始匹配的，如果整个字符串没有则返回None，且只匹配一个符合要求的字符串
• 用法

import re
pat = re.compile(r'abc123456', re.I)        # re.I：表示忽略大小写
b = pat.search('defabc123456')
print(b.group())
-------------------输出-----------------------
None
1
2
3
4
5
6

5.4:findall方法

• 与match方法和search方法的不同之处就是，前两个方法都是单值匹配，而findall方法是全文匹配，返回的形式为一个列表。因为返回形式是一个列表，所以不用使用gloup方法来显示pattern对象的内容。注意如果返回值是一个空列表，可能是正则表达式的模板错了
• 用法

import re
pat = re.compile(r'abc123abc')
a = pat.findall('123abc123')
print(a)
--------输出---------
['abc123','abc123']
1
2
3
4
5
6

5.5:spilt方法

• 参数：
  • 1：pattern:分割字符串的标志，就是以什么作为分割的标准
  • 2：maxsplit:最大的分割次数，默认为最多次，也就是分割完全
• 用法

import re
s = '1+2*3/4-5'
a = re.split(r'[\+\-\*\/]',s)
print(a)
----------输出----------------------
['1','2', '3', '4']
1
2
3
4
5
6

• 注意：split方法的返回值也是一个咧列表

5.6：sub方法

• 使用一个新的字符来代替另一个旧的字符，和字符串的replace方法的用法相似
• 用法

import re
a = '1211111111456789'
c = re.sub('1', '2', a)
print(c)
-------------输出------------
2222222222456789
1
2
3
4
5
6

• 总结
  • sub方法的默认替换是替换全部的字符

6：分组功能

• 把已经匹配到的内容，再次筛选出，我需要的内容，相当于二次分组，说白了，我不仅要筛选内容还要获得内容
• 实现分组的方法：使用小括号（）来进行分组
• 获得分组的内容：使用gloup()方法来获得
• 注意：
  • gloup()：获得整个分组，也就是这个字符串的本身
  • gloup(1)：获取取第一个分组
  • gloup(n)：获取第n个分组，注意分组的开始是由1开始的
  • gloup(0)：获取整个分组
  • gloups()：获取所有的分组，且把返回值返回保存在一个元组中
• 实例

import re
s = 'apple price is $66,banana price is $55'
# 需求是匹配 $66 $55
pat = r'.+(\$\d+).+(\$\d+)'
a = re.search(pat, s)
print(a.group())
print(a.group(0))
print(a.group(1))
print(a.group(2))
print(a.groups())
---------------输出-------------------
apple price is $66,banana price is $55
apple price is $66,banana price is $55
$66
$55
('$66', '$55')
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

7:flag匹配模式

7.1:re.S

• 使‘.’这个通配符，能够匹配换行在内的所有字符，针对多行匹配

7.2：re.I

• 使匹配对大小写不敏感，也就是忽略大小写的匹配