re模块——python篇

re模块

编译

re.compile(正则表达式) - 编译正则表达式，创建正则表达式对象

import re
# 编译
co = re.compile(r'\d*')
print(re.fullmatch(co, ''))
print(re.fullmatch(co, '123'))
# 使用compile返回正则对象，可以直接用对象.函数名()的方式调用re模块的方法
print(co.fullmatch('2342'))
"""
<re.Match object; span=(0, 0), match=''>
<re.Match object; span=(0, 3), match='123'>
<re.Match object; span=(0, 4), match='2342'>
"""

匹配

• fullmatch(正则表达式, 字符串) - 完全匹配（整个字符串和正则表达式进行匹配）

  # fullmath 完全匹配
  print(re.fullmatch(r'\d[a-z]+', '9abc'))
  

• match(正则表达式, 字符串) - 匹配字符串开头，如果匹配不到结果是None，如果匹配成功了结果是匹配对象

  # math 匹配字符串开头
  print(re.match(r'nba', 'nba123'))
  print(re.match(r'_', 'nba123'))
  print(re.match(r'_', '_nba123'))
  """
  <re.Match object; span=(0, 4), match='9abc'>
  <re.Match object; span=(0, 3), match='nba'>
  None
  <re.Match object; span=(0, 1), match='_'>
  """
  

• 匹配对象.group() - 获取整个正则表达式匹配到结果

  result = re.fullmatch(r'\d[a-z]+', '9abc')
  print(result.group())  # 9abc
  result = re.match(r'nba', 'nba123')
  print(result.group())  # nba
  

• 匹配对象.group(分组号) - 获取正则表达式中指定的分组匹配到的结果(分组号从1开始)

  re_str = r'(\d{2})-([a-z]{3})'
  result = re.match(re_str, '23-sjm回款及时发货')
  print(result.group(1))  # 23
  print(result.group(2))  # sjm
  

• 获取匹配到的子串的范围

  # 匹配对象.span()
  print('===============')
  print(result.span())  # (0, 6)
  print(result.span(2))  # (3, 6)
  

• 获取原字符串

  # 匹配对象.string
  print(result.string)  # 23-sjm回款及时发货
  

查找

• search(正则表达式,字符串) - 在字符串中查找第一个能和正则表达式匹配的子串，找到返回对象，未找到返回None。

  # search
  str1 = 'and123=hu123aaa456klk98!ll7hu123oop'
  result = re.search(r'\d+', str1)
  print(result)  # <re.Match object; span=(3, 6), match='123'>
  

• findall(正则表达式,字符串) - 获取字符串中所有满足正则表达式的子串，返回一个列表，列表中的元素是字符串

  str1 = 'and123=hu123aaa456klk98!ll7hu123oop'
  result = re.findall(r'\d+', str1)
  print(result)  # ['123', '123', '456', '98', '7', '123']
  

  # findall中如果有分组，只获取分组匹配中的内容
  result = re.findall(r'\d+[a-z]', str1)
  print(result)
  result = re.findall(r'(\d+)[a-z]', str1)
  print(result)
  """
    ['123a', '456k', '7h', '123o']
    ['123', '456', '7', '123']
  """ 
  

• finditer(正则表达式,字符串) - 获取字符串中所有满足正则表达式的子串。返回一个迭代器，迭代器中的元素是匹配对象

  st2 = '9h3jabc===9k2mabc9293h0oabc==!!!'
  result = re.findall(r'(\d[a-zA-Z]){2}abc', st2)
  print(result)
  # finditer
  result = re.finditer(r'(\d[a-zA-Z]){2}abc', st2)
  print(result)
  for i in result:
      print(i.group())
  """
  ['3j', '2m', '0o']
  <callable_iterator object at 0x0000016524CF2C08>
  9h3jabc
  9k2mabc
  3h0oabc
  """
  

切割

• split(正则表达式，切割的字符串，切割次数) - 将字符串中能和正则表达式匹配的子串作为切割点，对字符串进行切割。返回值是列表，列表中的元素是字符串

  # split(正则表达式, 字符串)  - 将字符串中能和正则表达式匹配的子串作为切割点，对字符串进行切割。返回值是列表，列表中的元素是字符串
  str1 = 'and123=hu123aaa456klk98!ll7hu123oop'
  result = re.split(r'\d+', str1)
  print(result)  # ['and', '=hu', 'aaa', 'klk', '!ll', 'hu', 'oop']
  # split(正则表达式, 字符串, 次数)  - 指定切割次数
  result = re.split(r'\d+', str1, 3)
  print(result)     # ['and', '=hu', 'aaa', 'klk98!ll7hu123oop']
  

替换

• sub(正则表达式, 字符串1, 字符串2, 次数) - 字符串中能和正则表达式匹配的子串全部替换为要替换的字符串

# sub(正则表达式, 字符串1, 字符串2)  -  将字符串2中能和正则表达式匹配的子串全部替换成字符串1
# sub(正则表达式, 字符串1, 字符串2, 次数)   -  限制替换次数
str1 = 'and123=hu123aaa456klk98!ll7hu123oop'
new_str1 = sub(r'\d+', '+', str1)
print(new_str1)

sentence = '你丫是傻 叉吗? 我操你大爷的. F u c k you.'
re_str = r'(?i)[操肏艹草曹]|f\s*u\s*c\s*k|s\s*h\s*i\s*t|傻\s*[比屄逼叉缺吊屌]|煞\s*笔'
new_sentence = sub(re_str, '*', sentence)
print(new_sentence)

正则表达式修饰符

修饰符	描述
re.I	使匹配对大小写不敏感
re.M	多行匹配，影响 ^ 和 $
re.S	使 . 匹配包括换行在内的所有字符

print(re.search(r'L','hello'))  # None
print(re.search(r'L', 'hello', re.I))  # 不区分大小写<re.Match object; span=(2, 3), match='l'>

# \w+$ 表示匹配以一个或者多个字母结尾
# re.M 可以进行多行匹配，每个换行都认为是一个结尾
print(re.findall(r'\w+$','i am boy\n you are girl\n he is man',re.M)) # ['boy', 'girl', 'man']
# 不实用re.M修饰符，只会匹配到最后的 man
print(re.findall(r'\w+$','i am boy\n you are girl\n he is man')) # ['man']

print(re.search(r'.','\n')) # None . 匹配除了 \n 以外的所有字符
print(re.search(r'.','\n',re.S)) # '\n'  匹配到了 \n