笔记20210518正则表达式和面向对象

最新推荐文章于 2024-10-18 00:00:00 发布

Andy_mq

最新推荐文章于 2024-10-18 00:00:00 发布

阅读量91

点赞数

分类专栏： python日常笔记文章标签： python

本文链接：https://blog.csdn.net/weixin_44160560/article/details/116996390

版权

python日常笔记专栏收录该内容

19 篇文章 0 订阅

订阅专栏

正则表达式和面向对象

检测类符号

\b——检测是否是单词边界

单词边界：凡是可以将两个单词区分开的符号都是单词边界，比如；空白字符、标点符号对应字符、字符串开头和结尾

检测类符号是在匹配成功的情况下看检测类符号所在的位置是否符合要求。
```
from re import fullmatch
re_str = r'123 \babc'
print(fullmatch(re_str, '123 abc'))

re_str = r'\d\d\b'
result = findall(re_str, '232asdadr54“g多福多寿455”')
print(result) # ['54', '55']
```

\B——检测是否不是单词边界

from re import fullmatch
re_str = r'\d\d\B'
result = findall(re_str, '232asdadr54“g多福多寿455')
print(result) # ['23', '45']

^——检测是否是对应字符串开头

from re import fullmatch
re_str = r'^\d\d'
result = findall(re_str, '232asdadr54“g多福多寿455')
print(result) # ['23']

$——检测是否是对应字符串结尾

from re import fullmatch
re_str = r'\d\d$'
result = findall(re_str, '232asdadr54“g多福多寿455')
print(result) # ['55']

匹配次数

'''
三个a：'aaa' == 'a{3}'
三个数字：'\d\d\d' == '\d{3}'
2到5个大写字母：'[A-Z]{2,5}'
'''

*——0次或者多次

a*——a出现0次或者多次

\d*——\d出现0次或多次，每次的一个\d可以使任意一个数字

[abc]*——[abc]出现0次或者多次，每次的[abc]都可以在a, b, c中选一个

from re import fullmatch
re_str = r'a\d*b'
print(fullmatch(re_str,'ab'))
print(fullmatch(re_str,'a2b'))
print(fullmatch(re_str,'a324b'))

re_str = r'a[123]*b'
print(fullmatch(re_str,'a1b'))
print(fullmatch(re_str,'ab'))

+——至少一次

from re import fullmatch
re_str = r'a\d+b'
print(fullmatch(re_str,'a4356b'))

?——匹配0次或者1次

from re import fullmatch
re_str = r'a\d?b'
print(fullmatch(re_str,'ab'))
print(fullmatch(re_str,'a4b'))

re_str = r'[-+]?[1-9]\d'
print(fullmatch(re_str, '12'))
print(fullmatch(re_str, '+12'))
print(fullmatch(re_str, '-12'))

{}——匹配次数

{N}——匹配N次
{M,N}——匹配M到N次（N可以取到）
{M,}——匹配至少M次
{,N}——匹配最多N次
```
# 1到2之间匹配2到5个a
from re import fullmatch
re_str = r'1a{2,5}2'
print(re_str, '1aaa2')
```

贪婪和非贪婪

在匹配次数不确定的时候，才有贪婪和非贪婪两种模式
贪婪：在能匹配成功的前提下取匹配次数最多次数。（默认）
非贪婪：在能匹配成功的前提下取匹配次数最少次数。（在匹配次数后加?）

from re import fullmatch, match
re_str = r'a.+b'
print(fullmatch(re_str, 'aklb'))
print(match(re_str, 'aklb公司工地施工'))
print(match(re_str, 'aklb公司工地施工b3213b'))  # 2次，9次，14次

re_str = r'a.+?b'
print(match(re_str, 'aklb公司工地施工b3213b'))  # 2次

分组和分支

分组——主要是用（）进行分组

用法1：将正则表达式中的一部分作为一个整体，进行相关操作，比如控制次数
用法2：重复—使用\M来重复前面第M个分组中的内容

from re import fullmatch
# 用法1
# 'amn23abf56dsd123'
re_str = r'([a-z]{3}\d{2}){3}'
print(fullmatch(re_str, 'amn23abf56dsd23'))

# '123a345d'
re_str = r'(\d{3}[a-z]){2}'
print(fullmatch(re_str, '123a345d'))

# 用法2
# '34erw34'
re_str = r'(\d\d)abc\1'
print(fullmatch(re_str, '34abc34'))

# '12=你好=你好=12'
re_str = r'(\d{2})=([\u4e00-\u9fa5]{2})=\2=\1'
print(fullmatch(re_str, '12=你好=你好=12'))
# '12=12=你好=你好'
re_str = r'(\d{2})=\1=([\u4e00-\u9fa5]{2})=\2'
print(fullmatch(re_str, '12=12=你好=你好'))

分支
1. 正则表达式1|正则表达式2
  
  先让正则1和字符进行匹配，如果成功就成功，失败就和正则表达式2进行匹配，如果正则2成功，结果匹配成功，否则失败（两个正则中只有一个可以匹配成功，结果都成功）
```
from re import fullmatch
re_str = r'^\d{2}abc|[A-Z]{3}abc'
print(fullmatch(re_str, '12abc'))
print(fullmatch(re_str, 'KLHabc'))
re_str = r'(\d{2}|[A-Z]{3})abc'
print(fullmatch(re_str, 'KJHabc'))
print(fullmatch(re_str, '23abc'))
```

转义符号

在本身具备特殊功能或者特殊意义的符号前加\，让其功能或意义消失，表示一个普通符号

from re import fullmatch
# '12.23
re_str = r'[1-9]\d\.\d{2}'
print(fullmatch(re_str, '12.23'))

# '2+8
re_str = r'\d\+\d'
print(fullmatch(re_str, '2+8'))

# 注意：独立具备特殊功能的符号在[]中功能会自动消失，例如：+、*、？、.、（）
# 本身在[]中有特殊意义的就要特别注意：[^]、[a-z]、[、]l
re_str1 = r'\d[+]\d'
print(fullmatch(re_str1, '2+8'))

re模块

compile(正则表达式)——根据正则表达式创建一个正则表达式对象

import re
from re import *
re_obj = re.compile(r'\d{3}')
result = re_obj.fullmatch('123')
print(result)

匹配类的方法

fullmatch：完全匹配

fullmatch(正则表达式，字符串)或者正则表达式对象.fullmatch(字符串)

功能：判断整个字符串是否符合正则表达式描述的规则，如果不符合返回None，符合返回匹配对象

match：字符串开头匹配

match(正则表达式，字符串)或者正则表达式对象.match(字符串)

功能：判断字符串开头是否符合正则表达式描述的规则，如果不符合返回None，符合返回匹配对象

获取匹配结果：

result = match(r'\d{3}', '777fdgd收到货后')
print(result)  # <re.Match object; span=(0, 3), match='777'>
# 匹配对象.group()——获取整个正则表达式匹配结果
# 匹配对象.group(N)——获取整个正则表达式中第N个分组匹配结果
print(result.group(),type(result.group()))
result = match(r'(\d{3})-([a-z]{2,5})', '123-adds大范甘迪发郭德纲')
print(result.group(0)) # 123-adds
print(result.group(1)) # 123
print(result.group(2)) # adds

获取匹配结果在原字符串中的位置

# 匹配对象.span（）
# 匹配对象.span（N）——第N个分组的字符范围，左闭右开
print(result.span()) # [0, 8)
print(result.span(2)) # [4, 8)

获取原字符串

# 匹配对象.string
print(result.string)  # 123-adds大范甘迪发郭德纲

查找类方法

search(正则表达式，字符串)
正则表达式.search(字符串)——获取字符串中第一个满足正则表达式的子串，如果没有返回None，否则返回匹配对象。

result = search(r'\d{3}', 'sda12334所发生的国风DFS--打三国杀097')
print(result)   # <re.Match object; span=(3, 6), match='123'>
print(result.group(0))  # 123  整个匹配结果
print(result.span())  # [3, 6) 匹配结果字符范围

findall(正则表达式, 字符串)
正则表达式对象.findall(字符串)——获取字符串中所有满足正则表达式的子串，以列表形式返回，列表中的元素是字符串

from re import *
str1 = 'shj23放大很多=-37ml嘎嘎嘎23,90ny4234'
# 提取所有数字
result = findall(r'\d+', str1)
print(result)  # ['23', '37', '23', '90', '4234']

# 如果正则中有分组，findall只提取匹配结果中分组匹配到的内容
# 提取前面是中文的数字
result = findall(r'[\u4e00-\u9fa5](\d+)', str1)
print(result)  # ['23']

result = findall(r'\d+-[a-z]+', 'shj23-gg放大很多=213-ml嘎嘎嘎23-bv,90ny4234')
print(result)  # ['23-gg', '213-ml', '23-bv']
# 有一个分组，只返回分组匹配内容
result = findall(r'(\d+)-[a-z]+', 'shj23-gg放大很多=213-ml嘎嘎嘎23-bv,90ny4234')
print(result)  # ['23', '213', '23']
# 有多个分组，以元组形式返回多个分组匹配到的内容
result = findall(r'(\d+)-([a-z]+)', 'shj23-gg放大很多=213-ml嘎嘎嘎23-bv,90ny4234')
print(result)  # [('23', 'gg'), ('213', 'ml'), ('23', 'bv')]
# 有分组的正则表达式需要返回整个结果，而不是只返回分组结果，在表达式外边加（）
result = findall(r'((\d+)-([a-z]+))', 'shj23-gg放大很多=213-ml嘎嘎嘎23-bv,90ny4234')
print(result)

finditer(正则表达式, 字符串) —— 产生迭代器
正则表达式对象.finditer(字符串)——获取字符串中所有满足正则表达式的字串，返回值是迭代器，迭代器中的元素是匹配对象

result = findall(r'\d+', 'shj23-gg放大很多=213-ml嘎嘎嘎23-bv,90ny4234')
print(result)  # ['23', '213', '23', '90', '4234']

result = finditer(r'(\d+)-([a-z]+)', 'shj23-gg放大很多=213-ml嘎嘎嘎23-bv,90ny4234')
print('整个正则匹配结果：', [x.group() for x in result])  # ['23-gg', '213-ml', '23-bv']

result = finditer(r'(\d+)-([a-z]+)', 'shj23-gg放大很多=213-ml嘎嘎嘎23-bv,90ny4234')
print('第一个分组匹配结果：', [x.group(1) for x in result])  # ['23', '213', '23']

切割

split(正则表达式, 字符串, 最大切割数)
正则表达式.split(字符串)——将字符串中所有满足正则表达式的字串作为切割点对字符串进行切割

str1 = '电风扇等方式123富商巨贾98fds-=公司的冯绍峰1345jgg--p/'
result = split(r'\d+', str1)
print(result)  # ['电风扇等方式', '富商巨贾', 'fds-=公司的冯绍峰', 'jgg--p/']

str2 = '是非得失，公司的第三个。公司广东省，很高很高分哈哈。浮点数'
result = split(r'[，。]', str2)
print(str2, type(str2))  # 是非得失，公司的第三个。公司广东省，很高很高分哈哈。浮点数 <class 'str'>

str2 = '是非得失，公司的第三个。公司广东省，很高很高分哈哈。浮点数'
result1 = split(r'[，。]', str2, 3)
print(result1)  # ['是非得失', '公司的第三个', '公司广东省', '很高很高分哈哈。浮点数']

替换

sub(正则表达式, 字符串1, 字符串2, 替换次数)
正则表达式对象.sub(字符串1, 字符串2)——将字符串2中所有满足正则表达式的字串都替换成字符串1

result2 = sub(r'\d+', '+', '电风扇等方式123富商巨贾98fds-=公司的冯绍峰1345jgg--p/')
print(result2)  # 电风扇等方式+富商巨贾+fds-=公司的冯绍峰+jgg--p/

result3 = sub(r'傻[bB逼]|f\s*u\s*c\s*k', '**********', 'f  u    c   k')
print(result3)  # **********

result4 = sub(r'\d+', '+', '电风扇等方式123富商巨贾98fds-=公司的冯绍峰1345jgg--p/', 2)
print(result4)  # 电风扇等方式+富商巨贾+fds-=公司的冯绍峰1345jgg--p/

匹配参数（1、单行匹配 2、忽略大小写）

单行匹配和多行匹配

默认是多行匹配。
多行匹配的时候，. 不能和\n（换行）匹配；单行匹配的时候，. 可以和\n匹配

单行匹配

# 单行匹配1
print(fullmatch(r'a.b', 'a\nb', flags=S)) # <re.Match object; span=(0, 3), match='a\nb'>
# 其中，S是从re模块中导入的

# 单行匹配2
print(fullmatch(r'(?s)a.b', 'a\nb'))  # <re.Match object; span=(0, 3), match='a\nb'>
# (?s)作用是指明是单行匹配

多行匹配

print(fullmatch(r'a.b', 'a\nb'))  # None

忽略大小写

a.默认不忽略大小写
b.忽略大小写的时候，大写字母可以和对应的小写字母匹配，小写字母也可以和对应的大写字母匹配

from re import *
print(fullmatch(r'[a-z]{3}123', 'sDa123'))  # None

# 忽略大小写方法1：
print(fullmatch(r'[a-z]{3}123', 'sDa123', flags=I))  # <re.Match object; span=(0, 6), match='sDa123'>

# 忽略大小写方法2：
print(fullmatch(r'(?i)[a-z]{3}123', 'sDa123'))

# 单行匹配和忽略大小写同时要求
# 方法1
print(fullmatch(r'abc.123', 'ABC\n123', flags=I|S))  # <re.Match object; span=(0, 7), match='ABC\n123'>
# 方法2
print(fullmatch(r'(?si)abc.123', 'ABC\n123'))  # <re.Match object; span=(0, 7), match='ABC\n123'>