re：正则表达式，字符串处理的杀手锏

最新推荐文章于 2022-07-28 23:20:31 发布

CWG2017

最新推荐文章于 2022-07-28 23:20:31 发布

阅读量311

点赞数

文章标签： python 操作系统

原文链接：http://www.cnblogs.com/traditional/p/11111320.html

版权

介绍

正则表达式是一种用形式化语法描述的文本匹配模式，可以进行复杂的字符串匹配。
Python中的正则表达式通过re模块提供，功能比Python内置的str更强，但是速度没有str提供的方法快。
因此如果内置的str方法可以解决，那么直接用就可以。如果不好解决，再使用正则。

1.查找文本中的模式

'''
re最常见的方法就是搜索文本中的模式。match和search函数接收pattern(模式)和text(文本)作为输入，找到这个模式时，就返回一个Match对象。
如果没有找到模式，则返回None。
每个Match对象包含有关匹配性质的信息，包括原输入字符串，所使用的正则表达式，以及模式在原字符串中出现的位置。
'''
pattern = "this"
text = "你知道this的含义吗？"
match = re.search(pattern, text)
print(match)  # <re.Match object; span=(3, 7), match='this'>
print(match.start())  # 3
print(match.end())  # 7
print(text[match.start(): match.end()])  # this
 
 
# 以上是search，那么match呢？
match = re.match(pattern, text)
print(match)  # None
# 返回结果为None，match和search比较类似，但match只能从头匹配查找， 而search可以在字符串的任意位置匹配查找。
 
 
# 即使有多个满足条件的也只会返回第一个。
print(re.search("this", "123this456this789this"))  # <re.Match object; span=(3, 7), match='this'>
 
 
# 如果没有则返回None，此时调用下面的start或end方法也会报错。会抛出AttributeError: 'NoneType' object has no attribute 'xxxxxx'
# 因此可以加上一层判断
match = re.match(pattern, text)
if match:
    print(match.start())

2.编译表达式

import re
 
 
'''
我们也可以将模式进行一个编译，比如我们有很多手机号，但我只查询以135开头的。
按照我们刚才讲的，可以这么做。
for number in number_list:
    if re.match("135", number):
        print(number)
这么做毫无疑问是可行的，但是我们每循环一次，pattern都要编译一次。既然pattern是固定不变的，我们是不是可以提前将它编译好呢？
答案是可以的
'''
# 得到编译之后的对象
comp = re.compile("135")
# 下面就可以直接使用这个编译的对象进行查找就可以了
number_list = ["13541258742", "18845214415", "13512441552"]
for number in number_list:
    # 可以看到，如果使用re的话，需要传入pattern，但是我们将pattern进行编译之后，就可以直接调用了。
    if comp.match(number):
        print(number)
        '''
        13541258742
        13512441552
        '''
 
'''
re.match(pattern, text) <==> re.compile(pattern).match(text)
'''
# 可以对比字符串，准确的说应该对比成类与对象
s = "abc|abcd|efg"
print(s.split("|"))  # ['abc', 'abcd', 'efg']
# 也可以使用str这个类来调用，但是不方便，于是我们都使用字符串本身，也就是类str的实例对象
print(str.split(s, "|"))  # ['abc', 'abcd', 'efg']
 
# summary：可以传入pattern和text作为参数，调用re.match,也可以将pattern编译之后，用编译之后的对象调用match方法，此时只需传入text

3.多重匹配

import re
 
 
'''
到目前为止，我们所获取的都是单个实例。如何将满足条件的所有文本全部获取呢？
可以使用findall函数
'''
pattern = "abc"
text = "abc|abc|abc|abc"
print(re.findall(pattern, text))  # ['abc', 'abc', 'abc', 'abc']
# 可以看到，直接将满足条件的所有实例全部以列表的形式获取出来了，并且如果满足条件的实例只有一个，那么得到的仍是一个列表，只是列表里面只有一个元素
 
# 除此之外还有一个迭代器模式
res = re.finditer(pattern, text)
print(res)  # <callable_iterator object at 0x00000000029C4400>
for v in res:
    print(v)
    '''
    <re.Match object; span=(0, 3), match='abc'>
    <re.Match object; span=(4, 7), match='abc'>
    <re.Match object; span=(8, 11), match='abc'>
    <re.Match object; span=(12, 15), match='abc'>
    '''
    # 得到的是一个Match对象

4.模式语法

import re
 
 
'''
除了简单的字面量文本字符串，正则表达式还支持更强大的模式。
'''
# 重复
'''
.：代表除换行符之外的任意字符
*：重复0次或者任意多次
+：重复1次或者任意多次
?：重复0次或者1次
{m}：出现m次
{m,n}：出现m次到n次，包含m和n，并且注意，逗号两边不要有空格
{m,}：省略n，那么表示至少出现m次，最多则没有限制
 
因此：* == {0,}   + == {1,}    ? == {0,1}
'''
 
# b出现一次到三次,注意这里不是ab出现一到三次，*+?{}只会作用于它的前一个字符
print(re.search("ab{1,3}", "abcabbc"))  # <re.Match object; span=(0, 2), match='ab'>
print(re.search("ab{2,3}", "abcabbc"))  # <re.Match object; span=(3, 6), match='abb'>
'''
可以看到都是从头开始找，开头是ab满足"ab{1,3}"，即使后面有abb也不会匹配了
而"ab{2,3}"则要求b至少出现两次，因此找到了后面的abb
'''
 
# 可以看到，要求是一到三次，ab，abb，abbb都符合，最终是取了abbb。
# 正则的模式则是贪婪模式，能往多了匹配就往多了匹配
print(re.search("ab{1,3}", "abbbbb"))  # <re.Match object; span=(0, 4), match='abbb'>
 
# *+?这些元字符也是同样的道理
print(re.search("ab*", "abbbbb"))  # <re.Match object; span=(0, 6), match='abbbbb'>
print(re.search("ab+", "abbbbb"))  # <re.Match object; span=(0, 6), match='abbbbb'>
print(re.search("ab?", "abbbbb"))  # <re.Match object; span=(0, 2), match='ab'>
 
 
# 那么如何不使用这种贪婪模式呢？可以直接在*+?{}后面加上?即可，表示关闭贪婪模式
# 出现一到三次，关闭贪婪，只获取一个b
print(re.search("ab{1,3}?", "abbbbb"))  # <re.Match object; span=(0, 2), match='ab'>
# *出现0次或多次，关闭贪婪模式，获取0次
print(re.search("ab*?", "abbbbb"))  # <re.Match object; span=(0, 1), match='a'>
# 显然获取一次
print(re.search("ab+?", "abbbbb"))  # <re.Match object; span=(0, 2), match='ab'>
# 出现0次或一次，关闭贪婪模式后显然获取0次
print(re.search("ab??", "abbbbb"))  # <re.Match object; span=(0, 1), match='a'>
# .表示除了换行符的任意字符
print(re.search(".{1,5}", "aaaaa"))  # <re.Match object; span=(0, 5), match='aaaaa'>
print(re.search(".{1,5}", "aa\naa"))  # <re.Match object; span=(0, 2), match='aa'>
 
 
# 字符集
'''
下面问题又来了，如果我想获取以a开头以c结尾，中间的一个字符必须是love中的一个，想获取这样的字符该怎么办呢？
首先两端好解决，关键是中间的字符要怎么表示？
这个时候字符集就派上用场呢？
[love]：用中括号把多个字符组合起来即可,表示匹配l、o、v、e四个字符中的一个
'''
print(re.findall("a[love]c", "awc|aec|afc|akc|adc"))  # ['aec']
# 字符集[love]就可以看做是一个整体，也可以搭配元字符使用
'''
[love]{1,3} 表示匹配出现一到三次的字符，什么的字符呢？l、o、v、e四个字符当中的某一个字符
'''
# v在[love]当中，匹配vvv
print(re.findall("[love]{1,3}", "vvv"))  # ['vvv']
# k不在但是v在，匹配vv
print(re.findall("[love]{1,3}", "kvv"))  # ['vv']
# 匹配v
print(re.findall("[love]{1,3}", "kv"))  # ['v']
# a不在，但ve在，匹配ve
print(re.findall("[love]{1,3}", "ave"))  # ['ve']
# findall是查找所有，l在[love]里面，o在，v在，但是最多出现三次匹配成功结束。继续查找，最后的e也在，但是_不在，所以匹配结束，得到e。
# y不在，但是o在，u又不在，所以又匹配出e。因此最终结果是['lov', 'e', 'o']。
print(re.findall("[love]{1,3}", "love_you"))  # ['lov', 'e', 'o']
 
# 那我如果想取反呢？也就是我要不在love里面的字符。可以使用[^love]，表示非l、o、v、e的任意字符
 
# 这便是字符集，但是又有一个问题。如果我想获取为小写字母的字符呢？难道把26的字母都写一遍吗？当然不用
# [a-z]表示所有的小写字母
# [A-Z]表示所有的大写字母
# [0-9]表示所有的数字
# [a-zA-Z0-9]表示所有的字母和数字
print(re.findall("[a-z][A-Z]", "aB|ac"))  # ['aB']
print(re.findall("[a-zA-Z]", "a|C|4|尻"))  # ['a', 'C']
print(re.findall("[a-zA-Z0-9]", "a|C|4|尻"))  # ['a', 'C', '4']
 
# 转义码
# \d表示数字
# \D表示非数字
# \w表示字母、数字，注意：这里包括中文
# \W表示非字母数字
# \s表示空白符(制表符、空格、换行等)
# \S表示非空白符
 
# 但是\在操作系统中会先做一层转义，因此需要两个\。在操作系统层面上，两个\变成一个\，然后再和d组合成\d进行正则比配
print(re.search("\\d{1,3}", "1234"))  # <re.Match object; span=(0, 3), match='123'>
# 那如果我想匹配\呢？
print(re.search("\\\\hello", "\\hello"))  # <re.Match object; span=(0, 6), match='\\hello'>
'''
要知道\在正则中也是有含义的，因此要匹配纯反斜杠，也需要做一次转义。
所以需要四个\，首先在在操作系统层面会转义，将四个\变成两个\，在正则中两个\变成一个\，此时的\便是普通的字符
但是这样会很麻烦，因此可以在字符串的开头加上一个r，表示这是原生的字符串，你不需要给我做任何的转义
'''
# 此时只需要一个反斜杠即可，可以看到Python中的\w是包含中文的
print(re.search(r"\w{1,2}", "古明地觉"))  # <re.Match object; span=(0, 2), match='古明'>
 
 
# 锚定
'''
有时除了匹配模式的内容外，我们还要对内容的位置进行一个限制。
^：这个符号我们刚才好像见过，[^seq]，表示不在seq里面的字符，但是如果放在开头的位置，则表示以某字符开头，如^abc则表示以abc开头的字符
$：表示以某字符结尾。如abc$表示以abc结尾的字符
\b：单词开头或末尾的空串
\B：不在单词开头或末尾的空串
'''
print(re.search(r"^abc", "abcd"))  # <re.Match object; span=(0, 3), match='abc'>
print(re.search(r"^abc", "aabcd"))  # None
 
print(re.search(r"abc$", "dabc"))  # <re.Match object; span=(1, 4), match='abc'>
print(re.search(r"abc$", "abcd"))  # None

5.限制搜索

import re
 
 
'''
已经编译的正则表达式，还可以指定查找的范围
'''
pattern = re.compile(r"123")
text = "123|123|123"
print(pattern.search(text, pos=2, endpos=7))  # <re.Match object; span=(4, 7), match='123'>
# 指定从2开始，7结束

6.用组解析匹配

import re
 
 
'''
有时我们想要提取某些内容中间的内容，比如xxxabcxxx，我想要夹在xxx和xxx之间的内容怎么办呢？
这个时候就可以用到分组
'''
# 有两个abc，但我要的是夹在xxx和xxx之间的abc
match = re.search(r"xxx(abc)xxx", "abcxxxabcxxx")
print(match)  # <re.Match object; span=(3, 12), match='xxxabcxxx'>
# 这样匹配依旧会匹配全局，怎么样才能把括号里面的内容给抽取出来呢？
print(match.group(0))  # xxxabcxxx
print(match.group(1))  # abc
'''
可以使用group函数，参数默认是0，表示全局。
参数为1，表示第一个括号里面的内容，参数为n，表示第n个括号里面的内容
'''
 
match = re.search(r"123(.+?)456(.+?)789", "123abc456def789")
print(match.group(0))  # 123abc456def789
print(match.group(1))  # abc
print(match.group(2))  # def
 
# 那么问题来了，如果是这样呢？
match = re.search(r"123((.+?)456(.+?))789", "123abc456def789")
print(match.group(0))  # 123abc456def789
print(match.group(1))  # abc456def
print(match.group(2))  # abc
print(match.group(3))  # def
'''
可以看到，我在(.+?)456(.+?)外层又加上了一层括号
分组的顺序，是从左往右，找到了(，就会进行分组，至于)，会自动进行匹配，所以group(1)是最外层的abc456def
group(2)是456左边的(.+?)，group(3)是456右边的(.+?)
'''
 
# 此外还可以给组进行命名。只需要在括号里面加上?P<name>即可，name是我们指定的分组的名字
match = re.search(r"123(?P<yoyoyo>.+?)456(?P<哈哈哈>.+?)789", "123纳尼456我屮艸芔茻789")
print(match.group("yoyoyo"), match.group("哈哈哈"))  # 纳尼 我屮艸芔茻
print(match.group(1), match.group(2))  # 纳尼 我屮艸芔茻
# 并且使用组的序号依旧是可以的
 
 
# 除了group之外，还可以使用groupdict和groups
match = re.search(r"123(?P<yoyoyo>.+?)456(?P<哈哈哈>.+?)789", "123纳尼456我屮艸芔茻789")
print(match.groups())  # ('纳尼', '我屮艸芔茻')
print(match.groupdict())  # {'yoyoyo': '纳尼', '哈哈哈': '我屮艸芔茻'}
 
# groups无论是否指定组名，都会获取到。但是groupdict只会获取指定组名的分组，比如说：
match = re.search(r"123(?P<yoyoyo>.+?)456(.+?)789", "123纳尼456我屮艸芔茻789")
print(match.groups())  # ('纳尼', '我屮艸芔茻')
# 可以看到没有指定组名的就获取不到了
print(match.groupdict())  # {'yoyoyo': '纳尼'}
 
 
# 此外在分组的时候，还可以指定管道符|,表示或者。比如
# jpg|png表示获取的是jpg或者png，注意：管道符会作用于两边的全部字符，比如：
# www.mashiro.jpg|png,则表示的是www.mashiro.jpg或者png
# www.mashiro.(jpg|png)，此时的管道符只会作用于括号里面两端的字符，表示www.mashiro.jpg或者www.mashiro.png
print(re.search(r"www\.mashiro\.(jpg|png)", "www.mashiro.jpg"))  # <re.Match object; span=(0, 15), match='www.mashiro.jpg'>
# 注意这里的\.表示转义，让.表示普通的. 不是具有匹配字符能力的.
 
# 但是这里又出现问题了，比如说
text = '''
    这里有图片哦www.1.jpg，有很多格式的哦
    www.2.png,想看吗，还会动哦，www.3.gif
    那还等什么呢？www.banana.jpg,
    快去吧，那个象征自由的男人在等着你www.象征自由的男人--尻比.png
'''
res = re.findall(r"www.+?(jpg|png|gif)", text)
print(res)  # ['jpg', 'png', 'gif', 'jpg', 'png']
'''
可以看到findall获取的自动是分组里面的内容，可我们要的是整体的链接啊。怎么办呢？一种方法是我在外面也加上括号不就行了
'''
 
res = re.findall(r"(www.+?(jpg|png|gif))", text)
print(res)  # [('www.1.jpg', 'jpg'), ('www.2.png', 'png'), ('www.3.gif', 'gif'), ('www.banana.jpg', 'jpg'), ('www.象征自由的男人--尻比.png', 'png')]
# 可以看到最外层的分组也被我们所捕获了，多个分组的内容回族和成一个元组。因此可以使用索引获取链接，但这还不是最完美的方法。
# 有什么办法，让里面的那个分组失去效果呢？就是说，我给你加上括号只是为了多匹配一些格式罢了，你就不要自作聪明地当做分组来处理了
# 答案是有的，只需要加上?:即可,在括号里面加上?:表示让分组失去效果，也就是不表示分组
res = re.findall(r"www.+?(?:jpg|png|gif)", text)
print(res)  # ['www.1.jpg', 'www.2.png', 'www.3.gif', 'www.banana.jpg', 'www.象征自由的男人--尻比.png']
# 可以看到匹配成功，而且此时最外层也不需要再加上括号了，因为里面的分组失去效果了，相当于就没有分组了，如果没有分组，那么默认匹配整体。
 
 
# 最后插一句，聊一聊www.+?(?:jpg|png|gif)，为什么要是.+?呢，如果是.+行不行，比如：
print(re.search(r"www.+?jpg", "www.1.jpg我屮艸芔茻www.2.jpg").group())  # www.1.jpg
# 我把?去掉，那么等于变成了贪婪模式。
print(re.search(r"www.+jpg", "www.1.jpg我屮艸芔茻www.2.jpg").group())  # www.1.jpg我屮艸芔茻www.2.jpg
# 那么会从第一个www开始，匹配到最后一个jpg，因此要注意开启非贪婪模式

7.搜索选项

import re
 
 
'''
选项标志是用来改变匹配引擎处理表达式的方式。
比如说，我们可以看看re.search()的函数原型
def search(pattern, string, flags=0):
这个pattern和string我们都知道，但是最后一个参数flags是什么鬼？
这个flags就是选项标志，也是我们接下来要说的内容
'''
 
# 大小写无关
'''
有些时候，我们不想区分大小写该怎么办呢？比如说aa和AA我们认为都是合法的。
'''
# 这便是flags的作用，可以用来改变引擎处理表达式的方式
# re.IGNORECASE表示忽略大小写敏感模式，其中re.IGNORECASE也可以写成re.I
match = re.match(r"aa", "aA", flags=re.IGNORECASE)
print(match)  # <re.Match object; span=(0, 2), match='aA'>
 
 
# 多行输入
'''
有两个标志会影响如何完成多行输入的搜索：MULTILINE和DOTALL。
MULTILINE表示^和*的锚定规则除了应用于整个字符串之外，还对每一行的开头和结尾起作用。（不常用）
DOTALL表示.这个元字符可以匹配换行符，默认情况下，.这个元字符是不能匹配换行符的，但是加上这个参数之后，便可以匹配换行符
 
注：re.MULTILINE可以写成re.M，re.DOTALL可以写成re.S
'''
match = re.match(r".+", "aabb\ncc")
print(match)  # <re.Match object; span=(0, 4), match='aabb'>
match = re.match(r".+", "aabb\ncc", flags=re.DOTALL)
print(match)  # <re.Match object; span=(0, 7), match='aabb\ncc'>
 
 
# Unicode
'''
默认情况下，正则表达式处理的都是Unicode文本，也就是说\w是可以匹配中文的。
如果我想只匹配ASCII码呢？可以使用re.ASCII，这样的话就不会匹配中文了.
re.ASCII也可以写成re.A
'''
print(re.match(r"\w+", "love中国"))  # <re.Match object; span=(0, 6), match='love中国'>
print(re.match(r"\w+", "love中国", flags=re.ASCII))  # <re.Match object; span=(0, 4), match='love'>

8.字符串替换

import re
 
 
'''
我们也可以将字符串进行一个替换
'''
text = "when i was young, i'd listen to the radio"
# 我要把当中所有的i替换成大写的I,怎么做呢？
# 可以使用re.sub函数，def sub(pattern, repl, string, count=0, flags=0):
# 参数：要替换的字符模式  替换成哪些字符  文本  替换的数量(默认为0，表示全部)  匹配模式
print(re.sub(r"i", "I", text))  # when I was young, I'd lIsten to the radIo
 
# 我要把里面的英文全部删除
text = "古明地觉(komeiji satori)是一个来自于东方地灵殿的女孩，它有一个妹妹，叫古明地恋(komeiji koishi)"
# 把\w都替换成空即可，但是注意\w默认是匹配中文(以及日文等等)的，所以要加上flags=re.A,表示只匹配ASCII码中的字符
print(re.sub(r"\w", "", text, flags=re.A))  # 古明地觉( )是一个来自于东方地灵殿的女孩，它有一个妹妹，叫古明地恋( )
# 不加flags的话，会把中文也剥掉了
print(re.sub(r"\w", "", text))  # ( )，，( )
 
# 除此之外还有一个函数叫做subn，和sub一样，但是除了返回替换的内容，还会返回替换的数量
print(re.subn("a", "b", "accaccacc"))  # ('bccbccbcc', 3)

9.利用模式拆分

import re
 
'''
类似于str.split，re也可以使用split函数，而且功能更加强大
'''
text = "abc1def55455ghi6621"
# 我要按照数字切割，最终只保留，abc def ghi该怎么做呢？
# 直接调用split即可， 此外还可以指定最多分割多少次，不指定默认为全部。这里表示用数字切割
print(re.split(r"\d", text))  # ['abc', 'def', '', '', '', '', 'ghi', '', '', '', '']
# 可以手动去掉空格
no_space = list(filter(lambda x: len(x), re.split(r"\d", text)))
print(no_space)  # ['abc', 'def', 'ghi']

转载于:https://www.cnblogs.com/traditional/p/11111320.html