1.正则表达式语法
正则表达式是用来匹配或者描述字符串的工具
用途：
a.判断输入的字符串是否是邮箱/手机号码。是否是IP地址
b.提取满足条件的字符串
c.字符串替换
python中通过re模块中相应的方法来支持正则表达式的匹配、查找和替换功能
代码示例
from re import fullmatch
"""
fullmatch(正则表达式字符串，字符串) --> 判断正则表达式和字符串是否完全匹配
正则表达式：就是一个字符串，字符串中是正则表达式语法。r'正则表达式'
正则表达式中包含两个部分，一个是正则表达式对应的字符，二是普通字符
"""
# 1\. .（点）：匹配任意字符
"""
一个.只匹配一个任意字符
"""
# 匹配一个字符串，第一个是'a',第二个字符是是任意字符，最后一个字符是b
re_str = r'a.b'
result = fullmatch(re_str, 'a&b')
print(result)
# 匹配一个长度是4，第一个字符和最后一个字符分别是a，中间是两个任意字符传
re_str = r'a..b'
result = fullmatch(re_str, 'a&%b')
print(result)
# 2.\w:匹配字母数字下划线
"""
一个\w匹配字符串
"""
# 匹配一个第一个字符是数字字母或者下划线，后面三个字符是任意字符的字符串
re_str = r'\w...'
print(fullmatch(re_str, '_jss'))
print(fullmatch(re_str, '5jss'))
# 3.\s：匹配任意空白字符
"""
空白字符：空格、制表符、回车、等，都是如空白字符
一个\s匹配一个空白字符
"""
re_str = r'a\sb'
result = fullmatch(re_str, 'a\nb')
print(result)
# 4.\d:匹配数字字符
re_str = r'\d\d\d'
re_str = fullmatch(re_str, '185')
print(result)
# 5.\b:检测边界
"""
一个\b不会去匹配一个字符，而是是单纯的检测\b出现的位置是否是单词边界
单词边界：字符串开始和结尾、空格、换行、标点符号等，可以将两个单词隔开的字符都是
"""
re_str = r'\babc'
result = fullmatch(re_str, 'abc')
print(result)
# 匹配 一个字符串前三位是abc，第四位是空白字符，后面是aaa,并且要求c是单词边界
re_str = r'abc\b.aaa'
result = fullmatch(re_str, 'abc,aaa')
print(result)
# 6.^：检测是否是字符串开头
re_str = r'^\d\d\d' # 判断一个字符串是否是三个数字开头
result = fullmatch(re_str, '123')
print(result)
# 7.$：检测是否是字符串结尾
re_str = r'abc$'
result = fullmatch(re_str, 'abc')
print(result)
# 8.\W：匹配非字母、数字、下划线
re_str = '\Wabc'
result = fullmatch(re_str, '#abc')
print(result)
# 9.\S：匹配非空白字符
re_str = r'\S...'
result = fullmatch(re_str, 'wsda')
print(result)
# 10.\D：匹配非数字字符
re_str = r'\D\w\w\w'
result = fullmatch(re_str, 's_ad')
print(result)
# 11.\B：检测是否不是单词边界
re_str = r'adfc\Bsd'
result = fullmatch(re_str, 'adfcsd')
print(result)
# 12.[]：匹配中括号中出现的任意一个字符
"""
一个中括号匹配一个字符
[字符集] ---> 匹配一个字符，这字符是字符集中的任意一个字符
例如：[abc],[\d+]
[字符1-字符2] ---> 匹配一个字符，这个 字符是编码Unicode编码值在字符1到字符2中的任意字符
例如：[1-9] --> 数字1到9 [a-z] --> 小写字母 [A-Z] --> 大写字母
[\u0031-\u0039] --> 数字1-9(可以写编码值)
[\u4E00-\u9fa5] --> 匹配所有中文
注意：-在中括号中，如果放在两个字符之间表示范围
"""
re_str = r'asd[sd]d'
result = fullmatch(re_str, 'asddd')
print(result)
re_str = r'[1-4]\d\d\d'
result = fullmatch(re_str, '4635')
print(result)
re_str = r'[\u4E00-\u9fa5][\u4E00-\u9fa5][\u4E00-\u9fa5]'
result = fullmatch(re_str, '很深刻')
print(result)
re_str = r'[19-]'
result = fullmatch(re_str, '-')
print(result)
# 匹配一个字符，是字母、数字、下划线 、空白
re_str = r'[\w\s]'
result = fullmatch(re_str, '_')
print(result)
# 13.[^字符集]：匹配一个不在字符集中的任意字符
"""
注意：^必须放在中括号中的最前面才有效
"""
# 匹配一个四位的字符串，第一位不是abc中的任意一个，后面两位是任意字符
re_str = r'[^abc]..'
re_str = r'[^1-9]..'
result = fullmatch(re_str, '9as')
print(result)
运行结果
<_sre.SRE_Match object; span=(0, 3), match='a&b'>
<_sre.SRE_Match object; span=(0, 4), match='a&%b'>
<_sre.SRE_Match object; span=(0, 4), match='_jss'>
<_sre.SRE_Match object; span=(0, 4), match='5jss'>
<_sre.SRE_Match object; span=(0, 3), match='a\nb'>
<_sre.SRE_Match object; span=(0, 3), match='a\nb'>
<_sre.SRE_Match object; span=(0, 3), match='abc'>
<_sre.SRE_Match object; span=(0, 7), match='abc,aaa'>
<_sre.SRE_Match object; span=(0, 3), match='123'>
<_sre.SRE_Match object; span=(0, 3), match='abc'>
<_sre.SRE_Match object; span=(0, 4), match='#abc'>
<_sre.SRE_Match object; span=(0, 4), match='wsda'>
<_sre.SRE_Match object; span=(0, 4), match='s_ad'>
<_sre.SRE_Match object; span=(0, 6), match='adfcsd'>
<_sre.SRE_Match object; span=(0, 5), match='asddd'>
<_sre.SRE_Match object; span=(0, 4), match='4635'>
<_sre.SRE_Match object; span=(0, 3), match='很深刻'>
<_sre.SRE_Match object; span=(0, 1), match='-'>
<_sre.SRE_Match object; span=(0, 1), match='_'>
None
2.正则表达式次数相关符号
代码示例
from re import fullmatch
import re
# 1.*(匹配0次或者多次)
"""
字符* --> 字符出现0次或者多次
"""
# 匹配0位或者多位的数字字符串
re_str = r'\d*'
print(fullmatch(re_str, '9656'))
print(fullmatch(re_str, '965s6'))
# 用一个正则表达式来检测一个标识符是否符合要求：数字字母下划线组成，数字不开头(位数至少1位)
re_str = r'[a-zA-Z_]\w*'
print(fullmatch(re_str, 'aSAD65_'))
# 2.+(匹配一次或者多次)
# abc前面有一个或者多个数字的字符串
re_str = r'\d+abc'
print(fullmatch(re_str, '4abc'))
# 3.?（0次或者一次）
re_str = r'.+?123'
print(fullmatch(re_str, 'a123'))
print(re.findall(re_str, 'a123asda456123158123'))
print('-------------------------------------')
# 练习：写一个正则表达式，匹配所有的整数（123，-2334，+9...（可匹配），012，-023..不能匹配 ）
re_str = r'[-+]?[1-9]\d*'
print(fullmatch(re_str, '456'))
print(fullmatch(re_str, '+056'))
# 4.{}(指定次数)
"""
{N} --> 匹配N次
{M,N} --> 匹配M到N次
{M,} --> 至少匹配M次
{,N} --> 最多匹配N次
"""
re_str = r'\d{3}'
print(fullmatch(re_str, '123'))
re_str = r'\d{3,}'
print(fullmatch(re_str, '1234'))
re_str = r'\d{,2}'
print(fullmatch(re_str, '12'))
re_str = r'\w{6,16}'
print(fullmatch(re_str, '12_ad54'))
# 判断密码是否符合要求：密码是由数字和字母组成并且6-16位
re_str = r'[\da-zA-Z]{6,16}'
print(fullmatch(re_str, '12ad5465asd'))
"""
几种常用的非贪婪匹配模型：
*? 重复任意次，但尽可能少重复
+? 重复1次或更多次，但尽可能少重复
?? 重复0次或1次，但尽可能少重复
{n,m}? 重复n到m次，但尽可能少重复
{n,}? 重复n次以上，但尽可能少重复
"""
运行结果
<_sre.SRE_Match object; span=(0, 4), match='9656'>
None
<_sre.SRE_Match object; span=(0, 7), match='aSAD65_'>
<_sre.SRE_Match object; span=(0, 4), match='4abc'>
<_sre.SRE_Match object; span=(0, 4), match='a123'>
['a123', 'asda456123', '158123']
-------------------------------------
<_sre.SRE_Match object; span=(0, 3), match='456'>
None
<_sre.SRE_Match object; span=(0, 3), match='123'>
<_sre.SRE_Match object; span=(0, 4), match='1234'>
<_sre.SRE_Match object; span=(0, 2), match='12'>
<_sre.SRE_Match object; span=(0, 7), match='12_ad54'>
<_sre.SRE_Match object; span=(0, 11), match='12ad5465asd'>
3.分支和分组
1.|分支
条件1|条件2 --> 先用条件1去匹配，如果匹配成功就匹配成功。如果条件1匹配失败，
用条件2去匹配。
注意：如果条件1匹配成功不会在匹配条件2
代码示例
re_str = r'[a-z]{3}|[A-Z]{3}'
print(re.fullmatch(re_str, 'abc'))
re_str = r'abc|d|aaa'
print(re.fullmatch(re_str, 'aaa'))
# 'abc' + W/H/Y
re_str = r'abc(W|H|Y)'
print(re.fullmatch(re_str, 'abcH'))
代码示例
re_str = r'[a-z]{3}|[A-Z]{3}'
print(re.fullmatch(re_str, 'abc'))
re_str = r'abc|d|aaa'
print(re.fullmatch(re_str, 'aaa'))
# 'abc' + W/H/Y
re_str = r'abc(W|H|Y)'
print(re.fullmatch(re_str, 'abcH'))
运行结果
<_sre.SRE_Match object; span=(0, 3), match='abc'>
<_sre.SRE_Match object; span=(0, 3), match='aaa'>
<_sre.SRE_Match object; span=(0, 4), match='abcH'>
2.()分组
a.组合(将括号中的内容作为一个整体进行操作)
b.捕获 --> 使用带括号的正则表达式匹配成功后,只获取括号中的内容
c.重复 --> 在正则表达式张可以通过\数字来重复前面()中匹配到的结果.数字代表前面第几个括号
代码示例
# a.组合
# 匹配一个字符串,以数字字母的组合出现3次
re_str = r'(\d[a-zA-Z]){3}'
print(re.fullmatch(re_str, '2h3j4k'))
re_str = r'(\d{3})abc'
print(re.fullmatch(re_str, '773abc'))
# b.捕获
# 找出字符串中符合表达式的字符串并返回一个列表
print(re.findall(re_str, 'euhasdkf55sfads546abc5dgs45s5_54'))
# c.重复
re_str = r'([a-z]{3})-(\d{2})\1\2' # \1将前面括号里面的内容重复一遍 \2将前面第二个括号里面的内容重复一遍...
print(re.fullmatch(re_str, 'hsn-78hsn78'))
运行结果
<_sre.SRE_Match object; span=(0, 6), match='2h3j4k'>
<_sre.SRE_Match object; span=(0, 6), match='773abc'>
['546']
<_sre.SRE_Match object; span=(0, 11), match='hsn-78hsn78'>
3.转义符号
正则表达式中可以通过在特殊的符号前加\,来让特殊的符号没有意义
. --> 任意字符 \. --> 字符.
+ --> 匹配一次或者多次 \+ --> 字符+
* ^ $等有特殊的功能
注意:在中括号中有特殊功能的符号,只代表符号本身
\不管在哪儿都需要转义
-在[]外面没有特殊功能
()需要转义
代码示例
re_str = r'\d{2}\.\d{2}'
print(re.fullmatch(re_str, '12.32'))
re_str = r'\d\+\d'
print(re.fullmatch(re_str, '4+5'))
re_str = r'[\\]'
print(re.fullmatch(re_str, '\\'))
re_str = r'\(\\'
print(re.fullmatch(re_str, '(\\'))
re_str = r'(\d{3})\1([a-z])\1'
print(re.fullmatch(re_str, '456456j456'))
运行结果
<_sre.SRE_Match object; span=(0, 5), match='12.32'>
<_sre.SRE_Match object; span=(0, 3), match='4+5'>
<_sre.SRE_Match object; span=(0, 1), match='\\'>
<_sre.SRE_Match object; span=(0, 2), match='(\\'>
<_sre.SRE_Match object; span=(0, 10), match='456456j456'>
4.re模块中的函数
代码示例
import re
"""
1.compile
compile(正则表达式字符串) --> 将正则表达式字符串转换成正则表达式对象
"""
re_object = re.compile(r'\d+')
print(re_object)
print(re_object.fullmatch('4656'))
# 2.fullmatch和match
"""
fullmatch(正则表达式字符串, 需要匹配的字符串) --> 用正则表达式去完全匹配字符串(匹配整个字符串)
返回匹配对象
match(正则表达式字符串, 字符串)
--> 匹配字符串开头,返回匹配对象或者None
"""
result = re.fullmatch(r'\d([a-zA-Z]+)', '2hjsd')
print(result, type(result))
# a.span(group=0) --> 获取匹配成功的开始下标和结束下标(开区间)
print(result.span(1))
print(result.start(1)) # 获取匹配到的结果开始下标
print(result.end(1)) # 获取匹配到的结果结束下标
# b.group(下标=0) --> 获取匹配结果
"""
group()/group(0) --> 获取正则表达式完全匹配的结果
group(index>0) --> 获取正则表达式中第index个分组匹配到的结果
"""
print(result.group())
print(result.group(1))
# c.string --> 获取被匹配的原字符串
print(result.string)
# match
result = re.match(r'\d([a-zA-Z]+)123', '2hjsd123ABC')
print('======', result)
# 3.search
"""
search(正则表达式,字符串) --> 查找字符串中满足正则表达式的第一个字符串.返回值是匹配对象或者None
"""
result = re.search(r'(\d)[a-zA-Z]+', 'dffs6fd8fs')
print(result.group(0))
print(result.group(1))
print(result.string)
# 练习:使用search匹配出一个字符串中所有的数字字符串
# 'abc34hjha8923hjhasd98as59k' --> 匹配出34, 8923 , 98, 59
re_str = r'\d+'
str1 = 'abc34hjha8923hjhasd98as59k'
result = re.search(re_str, str1)
print('========')
while result:
print(result)
print(result.string)
str1 = str1[result.end():]
result = re.search(re_str, str1)
# 4.findall()
"""
findall(正则表达式, 字符串) --> 获取字符串中满足正则表达式的所有的字串,返回一个列表
注意:如果正则表达式中有分组,取值的时候只取分组中匹配到的结果
如果有多个分组,将会每个分组匹配到的结果作为一个元组的元素返回
"""
re_str = r'(\d+)k([a-z]+)'
str1 = 'abc34hjha8923khjhasd98as59k'
result = re.findall(re_str, str1)
print(result)
# 5.finditer
"""
finditer(正则表达式, 字符串) --> 获取所有满足正则条件的子串,返回值是迭代器,迭代器中的元素是匹配对象
"""
re_str = r'\d+'
str1 = 'abc34hjha8923khjhasd98as59k'
result = re.finditer(re_str, str1)
for item in result:
print(item)
# result = str1.split('h')
# print(result)
# 6.split
"""
split(正则表达式, 字符串) --> 将字符串按照满足条件的字串进行分隔
"""
str1 = 'ahs1sssa8j-jkad892alkd55+jkad2'
re_str = r'[-+]'
result = re.split(re_str, str1)
print(result)
# 7.sub
"""
sub(正则表达式, repl, 字符串) --> 将字符串中满足正则表达式条件的字串替换成repl
返回替换后的字符串
"""
result = re.sub(r'\d+', '*', str1)
print(result)
result = re.sub(r'傻叉|逼|fuck|妈的|智\s*障', '*', '智 障')
print(result)
运行结果
re.compile('\\d+')
<_sre.SRE_Match object; span=(0, 4), match='4656'>
<_sre.SRE_Match object; span=(0, 5), match='2hjsd'> <class '_sre.SRE_Match'>
(1, 5)
1
5
2hjsd
hjsd
2hjsd
====== <_sre.SRE_Match object; span=(0, 8), match='2hjsd123'>
6fd
6
dffs6fd8fs
========
<_sre.SRE_Match object; span=(3, 5), match='34'>
abc34hjha8923hjhasd98as59k
<_sre.SRE_Match object; span=(4, 8), match='8923'>
hjha8923hjhasd98as59k
<_sre.SRE_Match object; span=(6, 8), match='98'>
hjhasd98as59k
<_sre.SRE_Match object; span=(2, 4), match='59'>
as59k
[('8923', 'hjhasd')]
<_sre.SRE_Match object; span=(3, 5), match='34'>
<_sre.SRE_Match object; span=(9, 13), match='8923'>
<_sre.SRE_Match object; span=(20, 22), match='98'>
<_sre.SRE_Match object; span=(24, 26), match='59'>
['ahs1sssa8j', 'jkad892alkd55', 'jkad2']
ahs*sssa*j-jkad*alkd*+jkad*
*
