• 【python中正则表达式的操作】

    正则表达式的操作

    文章目录

    正则表达式（称为 RE、或正则表达式或正则表达式模式）：本质上是一种嵌入 Python 中并通过re模块提供的小型、高度专业化的编程语言。使用这种小语言，可以为要匹配的可能字符串集指定规则；这个集合可能包含句子、电子邮件地址、TeX 命令或任何特定格式的字符串。

    正则表达式语言相对较小且受限制，因此并非所有可能的字符串处理任务都可以使用正则表达式完成。也有一些任务可以用正则表达式完成，但会使得表达式变得非常复杂。在这些情况下，可以通过编写 Python 代码来进行处理；虽然 Python 代码会比复杂的正则表达式处理得慢，但它也可能会更容易理解。

    • 在python中使用re模块来使用正则表达式
    • 具体的正则表达式规则可查看 正则表达式基础

    搜索字符串

    match()方法

    • match(pattern, string, flag=0)

      • 确定正则表达式是否在字符串开头匹配，只能匹配在字符串开头的符合表达式的子字符串。
      • 匹配返回一个匹配对象实例，否则返回None
      • 使用group()方法输出匹配到的字符串

    • 栗子:

      import re  # 导入正则包re

content1 = 'Hello world! hi666'# 要进行匹配的字符串
res1 = 'Hello'# 正则表达式1
res2 = 'hi'# 正则表达式2

result1 = re.match(res1, content1)
result2 = re.match(res2, content1)

if result1 is not None:  #需要判断不是None才能输出匹配后的字符串, 不然是None的话直接输出会报错
    print(result1.group()) # 输出匹配得到的字符串
    print(result1.span())# 输出输出匹配的范围(即索引切片范围)
    print(content1[0:5]) # 与这个效果一样
else:
    print("没有匹配到内容")

print(result2)  # 若匹配到返回匹配对象, 而不是字符串; 若不匹配到则返回None

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17

      输出结果:

      Hello
(0, 5)
Hello
None

      • 1
      • 2
      • 3
      • 4

    search()方法

    • search(pattern, string, flag=0)

      • 扫描整个字符串寻找匹配符合正则表达式pattern的字符串
      • 匹配返回一个匹配对象实例，否则返回None
      • 与match()不同的是它可以查找不在字符串开头的符合条件的字符串
      • 只匹配符合条件的第一个字符串，即匹配到就停止， 不会继续向后匹配
      • 使用group()方法输出匹配到的字符串

    • 栗子:

      import re  # 导入正则包re

# 栗子1
content1 = 'Hello world! hi666'# 要进行匹配的字符串
res1 = '\sworld!'# 正则表达式1
res2 = 'haha'# 正则表达式2

# search(正则表达式,匹配内容)
result1 = re.search(res1, content1)
result2 = re.search(res2, content1)

if result1 is not None:  #需要判断不是None才能输出匹配后的字符串, 不然是None的话直接输出会报错
    print(result1.group()) # 输出匹配得到的字符串
    print(result1.span())# 输出输出匹配的范围(即索引切片范围)
    print(content1[5:12]) # 与这个效果一样
else:
    print("没有匹配到内容")

print(result2)  # 若匹配到返回匹配对象, 而不是字符串; 若不匹配到则返回None


# 栗子2
content2 = 'my telephone number is 1234567'# 要进行匹配的字符串
res3 = 'one(.+)(\s)(\d+)'
result3 = re.search(res3, content2)
if result3 is not None:  #需要判断不是None才能输出匹配后的字符串, 不然是None的话直接输出会报错
    print(result3.group(1)) # group(1)表示匹配到的第一个组(即正则字符串中的第一个括号)匹配到的内容
    print(result3.group(2)) # 正则表达式第二个括号匹配到的内容
    print(result3.group(3)) #正则表达式第三个括号匹配到的内容
    # 注意正则表达式中的括号将内容进行分组
    print(result3.group())  # 匹配到的所有内容
else:
    print("没有匹配到内容")

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
      • 19
      • 20
      • 21
      • 22
      • 23
      • 24
      • 25
      • 26
      • 27
      • 28
      • 29
      • 30
      • 31
      • 32
      • 33

      输出结果:

       world!
(5, 12)
 world!
None
 number is
 
1234567
one number is 1234567

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8

    findall()方法

    • findall(pattern,string,flags=0)

      • 返回的结果是列表
      • 匹配到所有符合表达式的字符串, 以列表的形式返回
      • 若没有匹配到则返回空列表

    • 栗子:

      import re
content = 'Hello world! hi666 hello hello 777'# 要进行匹配的字符串

res1 = 'Hello\s'  #正则表达式1
results1 = re.findall(res1, content)
if results1 is not None:
    print(results1)
else:
    print("没有匹配到内容")


res2 = 'hello'  #正则表达式2
results2 = re.findall(res2, content)
if results2 is not None:
    print(results2)
else:
    print("没有匹配到内容")

res3 = 'haha'  #正则表达式3
results3 = re.findall(res3, content)
print(results3)


res4 = '7'  #正则表达式1
results4 = re.findall(res4, content)
if results4 is not None:
    print(results4)
else:
    print("没有匹配到内容")

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
      • 19
      • 20
      • 21
      • 22
      • 23
      • 24
      • 25
      • 26
      • 27
      • 28
      • 29

      输出结果:

      ['Hello ']
['hello', 'hello']
[]
['7', '7', '7']

      • 1
      • 2
      • 3
      • 4

    finditer()方法

    • 查找 RE 匹配的所有子字符串，并将它们作为迭代器返回。

    • 和findall()方法很相似, 只不过它不是返回列表

    • finditer(pattern,string,flags=0)

    • 栗子:

      import re
content = 'Hello world! hi666 hello hello 777'# 要进行匹配的字符串

res = 'hello\s'  #正则表达式
itertor = re.finditer(res, content)  # 返回的是迭代器
for s in itertor:
    print(s.group()) # s是一个匹配对象实例

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7

      输出结果

      hello 
hello 

      • 1
      • 2

    修改字符串

    sub()方法

    • sub(pattern, repl, string, count=0, flags=0)

      • 直接修改原字符串
      • sub(正则表达式, 被替换的内容, 原字符串)

    • 栗子:

      import re

content = 'hello world ,hello, hello!'
res = 'hello'   # 正则表达式
rep = 'hi'  #替换的内容
content = re.sub(res, rep, content)
print(content)

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7

      输出

      hi world ,hi, hi!

      • 1

    subn()方法

    • 与 执行相同的操作sub()，但返回新字符串和替换次数
    • subn(pattern,repl,string,count,flags=0)
    import re

content = 'hello world! hello, hello'
res = 'hello'   # 正则表达式
rep = 'hi'  #替换的内容
content = re.subn(res, rep, content)
print(content)  #返回一个包含新字符串值和已执行替换次数的元组

content1 = 'hello world! hello, hello'
content2 = re.subn(res, rep, content1,2)  # 后面的count参数是替换的次数
print(content2)  #返回一个包含新字符串值和已执行替换次数的元组

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11

    输出效果:

    ('hi world! hi, hi', 3)
('hi world! hi, hello', 2)

    • 1
    • 2

    编译正则表达式

    • 正则表达式被编译成模式对象，这些对象具有各种操作方法，例如：搜索模式匹配或执行字符串替换。

    • compile()方法

      • compile(pattern, flags=0)

        • 将正则表达式res编译成一个正则对象并返回，以便复用

      • 栗子 :

        import re

content1 = '2022-11-12 12:00'
content2 = '2021-11-11 12:55'
content3 = '2021-11-12 12:55'
pattern1 = re.compile('\d{2}:\d{2}') #编译成模式对象, 可以重复使用
pattern2 = '\d{2}:\d{2}'   # pattern1和pattern2的正则表达式规则一样, 但有什么区别呢?
result1 = re.sub(pattern1, '', content1)
result1 = re.sub(pattern1, '', content2)
result2 = re.sub(pattern2, '', content3)
result3 = pattern1.sub('', content1)   #当做对象使用
result4 = pattern1.sub('', content2)   #当做对象使用
print(result1, result2, result3,result4)
print(pattern1)   # 输出的是对象

        • 1
        • 2
        • 3
        • 4
        • 5
        • 6
        • 7
        • 8
        • 9
        • 10
        • 11
        • 12
        • 13
        • 14

        输出:

        2021-11-11  2021-11-12  2022-11-12  2021-11-11 
re.compile('\\d{2}:\\d{2}')

        • 1
        • 2

    • 正则表达式作为字符串传给re.compile()来创建一个模式对象，这些正则表达式不是python语言的核心，因此并没有为表达他们而创建特殊语法，re模块只是python中的一个C拓展模块。

    tips :

    re.sub(pattern, repl, string) # 模块的函数

    与

    p = re.compile(pattern)

    p.sub(repl, string) # 对象的函数

    的效果是一样的

    split()方法

    • 将字符串拆分为列表，将其拆分到 RE 匹配的任何位置
    • 它是re对象的split()方法
    • 它和字符串的split方法类似,但字符串的split()仅支持按空格或者按固定字符拆分
    • split(string[, maxsplit=0])

    栗子 :

    import re

p= re.compile('\d')  # 用数字将字符串分割开

res1 = p.split("y1s2d3p")
print(res1)

res2 = p.split("y1s2d3p",2)  # 后面的参数是代表将字符串分几次, 分两次, 就会有三部分, 该例子最多分成四部分
print(res2)

# 模块级函数
# 与上面的效果一样
res = re.split('\d',"y1s2d3p")
print(res)

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14

    输出效果 :

    ['y', 's', 'd', 'p']
['y', 's', 'd3p']
['y', 's', 'd', 'p']

    • 1
    • 2
    • 3

    方法后带的参数

    flags的一些常用值

    • re.A : 制作\w, \W, \b, \B, \d, \D,\s并\S 执行仅 ASCII 匹配而不是完整的 Unicode 匹配。这仅对 Unicode 模式有意义，对于字节模式被忽略。

    • re.I : 使匹配对大小写不敏感

    • re.S : 使.匹配包括换行符在内的所有字符

    • re.X : 忽略注释的内容

      • a = re.compile(r"""\d +  # 整数部分
                   \.    # 小数点
                   \d *  # 小数位的数字部分""", re.X)

b = re.compile(r"\d+\.\d*") #与a的效果一样

        • 1
        • 2
        • 3
        • 4
        • 5

    栗子 :

    import re

content = 'AbcaBcd ddd'
pattern1 = 'abc'
result1 = re.findall(pattern1, content,re.I)  # 使匹配对大小写不敏感, 即不分大小写
print(result1)
pattern2 = 'd(.+)'
result2 = re.findall(pattern2, content)  #使正则表达式中的'.'字符可以匹配包括换行符在内的所有字符
print(result2)

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9

    输出结果 :

    ['Abc', 'aBc']
[' ddd']

    • 1
    • 2

    总结

    模式对象常见的方法和属性

    搜索字符串:

    • match() : 确定 RE 是否在字符串的开头匹配。

      • 如果找不到匹配项，则search()返回None，如果成功则返回一个匹配对象实例。

    • search() : 扫描一个字符串，寻找该 RE 匹配的任何位置。

    • findall() : 查找 RE 匹配的所有子字符串，并将它们作为列表返回。

    • finditer() : 查找 RE 匹配的所有子字符串，并将它们作为迭代器返回。

    修改字符串:

    • sub() : 直接修改原字符串，替换所有符合正则表达式的原字符串的内容， 返回的是字符串

    • subn() ： 直接修改原字符串，替换所有符合正则表达式的原字符串的内容， 返回一个包含新字符串值和已执行替换次数的元组。可以控制替换的次数。

    • split() ： 将字符串拆分为列表，将其拆分到正则表达式匹配的任何位置

    注意 : 它们都是re模块下的方法

    当返回的是一个匹配对象实例，它会有以下常见的方法和属性

    • group() : 返回RE匹配的字符串

    • start() : 返回匹配开始的位置

    • end() : 返回匹配结束的位置

    • span() : 返回包含匹配的位置元组

    • 举个栗子：

      import re

content = "my num is 110"
p = re.compile('\d+')  #匹配数字
res = p.search(content)  # 返回一个匹配对象实例
print(res.group())  # 匹配的字符串
print(res.start())  # 开始匹配的位置
print(res.end())   # 匹配结束的位置
print(res.span())  # 匹配的位置元组

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9

      输出结果:

      110
10
13
(10, 13)

      • 1
      • 2
      • 3
      • 4

    主页 点赞 收藏 评论

    参考资料:

    https://www.jb51.net/article/242656.htm

    python正则表达式操作官方文档 —— 使用re库进行操作正则表达式

    python正则表达式 HOWTO官方文档 ——正则表达式的规则

  • 相关阅读:
    CORBA 架构体系指南（通用对象请求代理体系架构）​
    unity烘焙过程与注意事项，希望你们少走弯路
    ＜vector模拟实现＞——《C++初阶》
    Python操作Jenkins API
    如何使用libgdx做游戏01---libgdx的安装
    nginx-反向代理缓存
    傅里叶变换
    掌握交易时机！
    计算机组成原理（二）运算方法和运算器
    springboot async异步处理方案
  • 原文地址：https://blog.csdn.net/honorzoey/article/details/126336690