• python的正则表达中的re库一些常用的方法

    元字符
    .

    1.匹配除 "\n" 之外的单个字符。

    2.匹配包括 '\n' 在内的任何字符，使用'[.\n]' 

    [...]        

    取反:[^.....]

    作为字符集，筛选出字符集中写着的的字符

    当加上^表示除了字符集中的字符不取，其他取

    |或者的意思，取其左边或者右边的字符

    预定义字符集
    \d匹配任意数字，等价于 [0-9]
    \D匹配任意 非 数字，等价于 [^0-9]
    \s匹配任意空白字符，等价于 [\t\n\r\f]
    \S匹配任意非空字符，等价于 [^\t\n\r\f]
    \w匹配字母数字及下划线，等价于 [a-zA-Z0-9]
    \W匹配非字母数字及下划线，等价于 [^a-zA-Z0-9]
    \b

    匹配一个单词边界，也就是只单词和空格间的位置。

    如 ‘oot\b' 可以匹配 ’quootr 中的 'oot'； 但不能匹配 'quoot' 中的 'oot'

    \B匹配非单词边界。'oot\B' 能匹配 "" 中的 'quootr'，但不能匹配 "quootr" 中的 'oot'

    我进行组合一些复杂的正则表达式的时候是为了快捷去晚上找一些现成的模式，然后再自己进行修改，变成符合自己需要的一些正则表达式。

    1. import re
    2.  
    3. # 正则表达式中的一些使用的符号
    4.  
    5. # 匹配出现符合条件的 0 次的或者是 多次
    6.  
    7. str1 = 'qwertyuio1ui3oo467j398k'
    8.  
    9. #  关键词: *    下面的句子就是进行匹配 零次 或者是 多次（多个字符） 符合是数字的意思
    10. pattern = re.compile(r'\d*')
    11. res = re.findall(pattern, str1)
    12. print(res)
    13. """"
    14. 显示的结果:
    15. ['', '', '', '', '', '', '', '', '', '1', '', '', '3', '', '', '467', '', '398', '', '']
    16. """
    17.  
    18. # 关键词: +  匹配一次或者是多次的结果
    19.  
    20. pattern = re.compile(r'\d+')
    21. res = re.findall(pattern, str1)
    22. print(res)
    23. """
    24. 显示结果:
    25. ['1', '3', '467', '398']
    26. """
    27.  
    28.  
    29. # 关键词: ?  匹配0次或者是1次的结果
    30.  
    31. pattern = re.compile(r'\d?')
    32. res = re.findall(pattern, str1)
    33. print(res)
    34. """
    35. ['', '', '', '', '', '', '', '', '', '1', 
    36. '', '', '3', '', '', '4', '6', '7', '', 
    37. '3', '9', '8', '', '']
    38. """
    39.  
    40.  
    41. # {m}精确匹配m次  (比如写进去的3，那么他就是匹配到是3个数字字符串的所有小字符串)
    42. pattern = re.compile(r'\d{3}')
    43. res = re.findall(pattern, str1)
    44. print(res)
    45. # 结果:['467', '398']
    46.  
    47.  
    48. # {m, n} 最少匹配m次，最多匹配n次
    49. # 记住在{}里面是不能随便加上空格的?
    50. pattern = re.compile(r'\d{1,3}')
    51. res = re.findall(pattern, str1)
    52. print(res)
    53. # 结果:['1', '3', '467', '398']

    match()函数只检测 目标字符(串) 是不是在string的开始位置匹配，search()会扫描整个string查找匹配, match()只有在0位置匹配成功才会有返回，如果不是开始位置匹配成功,match()就会返回None

    代码解释：

    import re

    m = re.match('lsp','hhttlsp')

    if m is not None: 

            print(m.group())

    else:

            print('noneFine')

    显示结果：

    noneFine

    n = re.search('lsp','hhttlsp')

    if n is not None:

            print(n.group())

    else:

            print(noneFine')

    显示结果：

    lsp

    1. import re
    2.  
    3. n = re.search('lsp','hhttlsp')
    4. if n:
    5.     print(n.group())
    6. else:
    7.     print('noneFine')
    8. # 显示结果：
    9. # lsp
    10.  
    11.  
    12. m = re.match('lsp','hhttlsp')
    13. if m:
    14.     print(m.group())
    15. else:
    16.     print('noneFine')
    17. # 显示结果：
    18. # noneFine

    python的re库有两个函数/方法用于实现搜索和替换功能: sub()和subn().两者几乎一样，都是将某字符串中所有匹配正则表达式的部分进行某种形式的替换.用来替换的部分通常是一个字符串，但它也可能是一个函数，该函数返回一个用来替换的字符串.subn()和 sub()一样，但subn()还返回一个表示替换的总数，替换后的字符串和表示替换总数的数字一起作为一个拥有两个元素的元组返回.

    1. # 可以使用sub()方法来进行查询和替换，sub方法的格式为：
    2. # sub(replacement, string[, count=0])
    3. # replacement是被替换成的文本
    4. # string是需要被替换的文本
    5. # count是一个可选参数，指最大被替换的数量
    6.  
    7. # 下面进行将所有的数字给进行替换掉
    8. pattern = re.compile(r'\d')
    9. res = re.sub(pattern, '替换掉的数字  ',str1)
    10. print(res)
    11. # 下文结果，为了方便大家看到换了多少个数字，我使用了换行将字符串给换行看出有几次换了数字
    12. """
    13. qwertyuio替换掉的数字  
    14. ui替换掉的数字  
    15. oo替换掉的数字  
    16. 替换掉的数字  
    17. 替换掉的数字  
    18. j替换掉的数字  
    19. 替换掉的数字  
    20. 替换掉的数字  k
    21. """
    1. # 加上显示修改了多少次
    2. res = re.subn(pattern, '替换掉的数字  ',str1)
    3. print(res)
    4. """
    5. 结果：
    6. ('qwertyuio替换掉的数字 
    7.  ui替换掉的数字  
    8.  oo替换掉的数字 
    9.   替换掉的数字 
    10.    替换掉的数字  
    11.    j替换掉的数字  
    12.    替换掉的数字 
    13.     替换掉的数字  
    14.     k', 8)
    17. """

    re.split(pattern, string, maxsplit=0, flags=0),如果匹配成功，则返回一个列表，否则返回原string列表；

    第1个参数：正则表达式

    第2个参数：要匹配查找的原始字符串；

    第3个参数：可选参数，表示最大的拆分次数，默认为0，表示全部分割；

    第4个参数：可选参数，标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等；

    特别注意: 此方法并不是完全匹配。它仅仅决定在字符串开始的位置是否匹配。所以当pattern结束时若还有剩余字符，仍然成功。若想进行完全匹配，可以在表达式末尾加上边界匹配符'$'

    1. str2 = '自然语言处理123机器学习456深度学习'
    2. pattern = re.compile(r'\d+')
    3. res = re.split(pattern, str2)
    4. print(res)
    5. # 结果:
    6. # ['自然语言处理', '机器学习', '深度学习']

    Python的re模块是第一个提出解决方案的模块：命名捕获组和命名后向引用。（？P group）将组的匹配捕获到后向引用“名称”中。

    1. str2 = '自然语言处理123机器学习456深度学习'
    2. pattern = re.compile(r'(?P\d+)(?P\D+)')
    3. m = re.search(pattern, str2)
    4. print(m.group('lsp'))
    5. # 结果为:
    6. # 机器学习
    1. str2 = '自然语言处理123机器学习456深度学习'
    2. pattern = re.compile(r'(?P\d+)(?P\D+)')
    3. m = re.search(pattern, str2)
    4. print(m.group('dota'))
    5. # 结果为:
    6. # 123

    进行号码的筛选，小尝试：

    1. # 筛选号码
    2. str3 = 'number  132-3209-*******'
    3. pattern = re.compile(r'(\d\d\d-\d\d)')
    4. res = re.search(pattern, str3)
    5. print(res.group())
    6. # 显示结果：
    7. # 132-32

    全部代码

    1. # -*- coding:utf-8 -*-
    2. # @Time : 2022-08-28 19:13
    3. # @Author : DaFuChen
    4. # @File : demo1.py
    5. # @software: PyCharm
    6.  
    7.  
    8. import re
    9.  
    10. # 正则表达式中的一些使用的符号
    11.  
    12. # 匹配出现符合条件的 0 次的或者是 多次
    13.  
    14. str1 = 'qwertyuio1ui3oo467j398k'
    15.  
    16. #  关键词: *    下面的句子就是进行匹配 零次 或者是 多次（多个字符） 符合是数字的意思
    17. pattern = re.compile(r'\d*')
    18. res = re.findall(pattern, str1)
    19. print(res)
    20. """"
    21. 显示的结果:
    22. ['', '', '', '', '', '', '', '', '', '1', '', '', '3', '', '', '467', '', '398', '', '']
    23. """
    24.  
    25. # 关键词: +  匹配一次或者是多次的结果
    26.  
    27. pattern = re.compile(r'\d+')
    28. res = re.findall(pattern, str1)
    29. print(res)
    30. """
    31. 显示结果:
    32. ['1', '3', '467', '398']
    33. """
    34.  
    35.  
    36. # 关键词: ?  匹配0次或者是1次的结果
    37.  
    38. pattern = re.compile(r'\d?')
    39. res = re.findall(pattern, str1)
    40. print(res)
    41. """
    42. ['', '', '', '', '', '', '', '', '', '1', 
    43. '', '', '3', '', '', '4', '6', '7', '', 
    44. '3', '9', '8', '', '']
    45. """
    46.  
    47.  
    48. # {m}精确匹配m次  (比如写进去的3，那么他就是匹配到是3个数字字符串的所有小字符串)
    49. pattern = re.compile(r'\d{3}')
    50. res = re.findall(pattern, str1)
    51. print(res)
    52. # 结果:['467', '398']
    53.  
    54.  
    55. # {m, n} 最少匹配m次，最多匹配n次
    56. # 记住在{}里面是不能随便加上空格的?
    57. pattern = re.compile(r'\d{1,3}')
    58. res = re.findall(pattern, str1)
    59. print(res)
    60. # 结果:['1', '3', '467', '398']
    61.  
    62. import re
    63.  
    64. n = re.search('lsp','hhttlsp')
    65. if n:
    66.     print(n.group())
    67. else:
    68.     print('noneFine')
    69. # 显示结果：
    70. # lsp
    71.  
    72.  
    73. m = re.match('lsp','hhttlsp')
    74. if m:
    75.     print(m.group())
    76. else:
    77.     print('noneFine')
    78. # 显示结果：
    79. # noneFine
    80.  
    81.  
    82. # 可以使用sub()方法来进行查询和替换，sub方法的格式为：
    83. # sub(replacement, string[, count=0])
    84. # replacement是被替换成的文本
    85. # string是需要被替换的文本
    86. # count是一个可选参数，指最大被替换的数量
    87.  
    88. # 下面进行将所有的数字给进行替换掉
    89. pattern = re.compile(r'\d')
    90. res = re.sub(pattern, '替换掉的数字  ',str1)
    91. print(res)
    92. # 下文结果，为了方便大家看到换了多少个数字，我使用了换行将字符串给换行看出有几次换了数字
    93. """
    94. qwertyuio替换掉的数字  
    95. ui替换掉的数字  
    96. oo替换掉的数字  
    97. 替换掉的数字  
    98. 替换掉的数字  
    99. j替换掉的数字  
    100. 替换掉的数字  
    101. 替换掉的数字  k
    102. """
    103.  
    104. # 加上显示修改了多少次
    105. res = re.subn(pattern, '替换掉的数字  ',str1)
    106. print(res)
    107. """
    108. 结果：
    109. ('qwertyuio替换掉的数字 
    110.  ui替换掉的数字  
    111.  oo替换掉的数字 
    112.   替换掉的数字 
    113.    替换掉的数字  
    114.    j替换掉的数字  
    115.    替换掉的数字 
    116.     替换掉的数字  
    117.     k', 8)
    120. """
    121.  
    122. str2 = '自然语言处理123机器学习456深度学习'
    123. pattern = re.compile(r'\d+')
    124. res = re.split(pattern, str2)
    125. print(res)
    126. # 结果:
    127. # ['自然语言处理', '机器学习', '深度学习']
    128.  
    129.  
    130. str2 = '自然语言处理123机器学习456深度学习'
    131. pattern = re.compile(r'(?P\d+)(?P\D+)')
    132. m = re.search(pattern, str2)
    133. print(m.group('dota'))
    134. # 结果为:
    135. # 123
    136.  
    137.  
    138.  
    139. # 筛选号码
    140. str3 = 'number  132-3209-*******'
    141. pattern = re.compile(r'(\d\d\d-\d\d)')
    142. res = re.search(pattern, str3)
    143. print(res.group())
    144. # 显示结果：
    145. # 132-32
    146.  
    147.  
    148.

  • 相关阅读:
    「AI知多少」第一期推荐《生命3.0》
    【力扣题:循环队列】
    PL2303驱动程序不支持WINDOWS 11及后续版本
    2021年下半年软件设计师上午真题答案及解析（五）
    优测云测试平台 | 有效的单元测试
    创建一个web项目
    docker run 命令详解（新手入门必备）
    【计算机视觉 | 图像分割】arxiv 计算机视觉关于图像分割的学术速递（8 月 28 日论文合集）
    怎么批量把图片转文字？教你几招轻松完成
    Web基础与HTTP协议
  • 原文地址：https://blog.csdn.net/blockshowtouse/article/details/126573110