正则表达式（二）

正则表达式符号

符号 解释 示例 说明
. 匹配任意字符 b.t 可以匹配bat / but / b#t / b1t等
\w 匹配字母/数字/下划线 b\wt 可以匹配bat / b1t / b_t等
但不能匹配b#t
\s 匹配空白字符（包括\r、\n、\t等） love\syou 可以匹配love you
\d 匹配数字 \d\d 可以匹配01 / 23 / 99等
\b 匹配单词的边界 \bThe\b
^ 匹配字符串的开始 ^The 可以匹配The开头的字符串
可以匹配.exe结尾的字符串
\W 匹配非字母/数字/下划线 b\Wt 可以匹配b#t / b@t等
但不能匹配but / b1t / b_t等
\S 匹配非空白字符 love\Syou 可以匹配love#you等
但不能匹配love you
\D 匹配非数字 \d\D 可以匹配9a / 3# / 0F等
\B 匹配非单词边界 \Bio\B
[] 匹配来自字符集的任意单一字符 [aeiou] 可以匹配任一元音字母字符
[^] 匹配不在字符集中的任意单一字符 [^aeiou] 可以匹配任一非元音字母字符

• 匹配0次或多次 \w*

• 匹配1次或多次 \w+
  ? 匹配0次或1次 \w?
  {N} 匹配N次 \w{3}
  {M,} 匹配至少M次 \w{3,}
  {M,N} 匹配至少M次至多N次 \w{3,6}
  | 分支 foo|bar 可以匹配foo或者bar
  (?#) 注释
  (exp) 匹配exp并捕获到自动命名的组中
  (?<name>exp) 匹配exp并捕获到名为name的组中
  (?:exp) 匹配exp但是不捕获匹配的文本
  (?=exp) 匹配exp前面的位置 \b\w+(?=ing) 可以匹配I'm dancing中的danc
  (?<=exp) 匹配exp后面的位置 (?<=\bdanc)\w+\b 可以匹配I love dancing and reading中的第一个ing
  (?!exp) 匹配后面不是exp的位置
  (?<!exp) 匹配前面不是exp的位置
  ? 重复任意次，但尽可能少重复 a.b
  a.*?b 将正则表达式应用于aabab，前者会匹配整个字符串aabab，后者会匹配aab和ab两个字符串
  +? 重复1次或多次，但尽可能少重复
  ?? 重复0次或1次，但尽可能少重复
  {M,N}? 重复M到N次，但尽可能少重复
  {M,}? 重复M次以上，但尽可能少重复
  说明：如果需要匹配的字符是正则表达式中的特殊字符，那么可以使用\进行转义处理，例如想匹配小数点可以写成.就可以了，因为直接写.会匹配任意字符；同理，想匹配圆括号必须写成(和)，否则圆括号被视为正则表达式中的分组。
  Python对正则表达式的支持

Python提供了re模块来支持正则表达式相关操作，下面是re模块中的核心函数。

函数 说明
compile(pattern, flags=0) 编译正则表达式返回正则表达式对象
match(pattern, string, flags=0) 用正则表达式匹配字符串 成功返回匹配对象 否则返回None
search(pattern, string, flags=0) 搜索字符串中第一次出现正则表达式的模式 成功返回匹配对象 否则返回None
split(pattern, string, maxsplit=0, flags=0) 用正则表达式指定的模式分隔符拆分字符串 返回列表
sub(pattern, repl, string, count=0, flags=0) 用指定的字符串替换原字符串中与正则表达式匹配的模式 可以用count指定替换的次数
fullmatch(pattern, string, flags=0) match函数的完全匹配（从字符串开头到结尾）版本
findall(pattern, string, flags=0) 查找字符串所有与正则表达式匹配的模式 返回字符串的列表
finditer(pattern, string, flags=0) 查找字符串所有与正则表达式匹配的模式 返回一个迭代器
purge() 清除隐式编译的正则表达式的缓存
re.I / re.IGNORECASE 忽略大小写匹配标记
re.M / re.MULTILINE 多行匹配标记
说明：上面提到的re模块中的这些函数，实际开发中也可以用正则表达式对象的方法替代对这些函数的使用，如果一个正则表达式需要重复的使用，那么先通过compile函数编译正则表达式并创建出正则表达式对象无疑是更为明智的选择。

一.正则表达式的符号

正则表达式：用来做字符串查找 匹配 切割用的一种工具

python对正则表达式的支持 ：提供了re模块（python内置模块），包含字符串 匹配 查找 切割等相关的方法
fullmatch(正则表达式，字符串)：用正则表达式和字符串来进行匹配，看是否能匹配成功
正则表达式：是一个符合正则规范的字符串

注意：正则表达式的字符串 前面一般要加r来阻止转义。因为正则表达式的符号中有很多代''的符号

其功能不是转义，而是表示特殊意义

    import re
    if __name__ == '__main__':
    #1. . :匹配任意字符
    re_str=r'..'#有几个点就匹配几个字符
    """匹配第一个字符是a第二个字符是b的字符串"""
    re_str=r'ab'
    """匹配第一个字符是a，匹配第二个字符是任意字符串"""
    re_str=r'a.'
    print(re.fullmatch(re_str,'ah'))

    #2. \w:匹配一个字符是字母 数字 或者下划线
    """匹配第一个字符是字母 数字或者下划线。第二个字符是字母数字 或者下划线的字符串"""
    re_str=r'\w\w'
    print(re.fullmatch(re_str,'b8'))

    re_str=r'\w.\w'
    print(re.fullmatch(re_str,'u(0'))

    #3. \s:匹配一个空白字符（空格 换行 制表符）
    """匹配第一个字符是a 第二个字符是空白 第三个字符是b的字符串"""
    re_str=r'a\sb'
    print(re.fullmatch(re_str,'a b'))
    #4.\d匹配一个数字字符
    re_str=r'\d\d\d'
    print(re.fullmatch(re_str,'123'))

    re_str=r'0\d\d'
    #匹配第一个字符是0 后面两个字符都是数字的字符串
    print(re.fullmatch(re_str,'019'))

    print(re.match(re_str, '0190')) #re.math置匹配与正则字符串相同长度的

    #5. \b检测边界(字符串结束 字符串开头,单词边界 一般的符号都可以作为单词边界)
    """匹配三个任意字符的前面和后面都是单词边界的字符串"""
    re_str=r'\b...\b'
    print(re.match(re_str,'dsa'))
    print(re.match(re_str,'asd,adw'))

    #6. ^ 检测字符串开始（^The --匹配一The开头的字符串）
    re_str=r'^The'
    print(re.fullmatch(re_str,'The'))
    print(re.findall(r'^The','Theasfd 6567'))

    #7. $检测字符串结束
    re_str=r'abc$'
    print(re.findall(re_str,'sadf sdg abc'))

    #8. \W匹配非字母 数字 下划线
    re_str=r'\W\w'
    print(re.fullmatch(re_str,' k'))
    print(re.fullmatch(re_str, '&k'))

    #9. \S 匹配非空白字符
    re_str = r'\S\d'
    print(re.fullmatch(re_str, 'D5'))

    #10. \D 匹配非数字字符
    """匹配一个字符是非数字字符，第二个字符是字母 数字 下划线"""
    re_str = r'\D\w'
    print(re.fullmatch(re_str, 'p5'))

    #11. \B 检测非边界
    """匹配前两个字符是a和b，第三个字符是c。并且检测b的后面是一个非边界"""
    re_str = r'ab\Bc'
    print(re.fullmatch(re_str, 'abc'))
    print(re.match(re_str, 'abc0'))

二.正则表达式符号组：

 import re

if __name__ == '__main__':
#1. []匹配[]中出现的任意一个字符
"""匹配一个字符串 钱的是你我是abc 第四位是字符集中的一位字符"""
re_str=r'abc[1a]'
print(re.fullmatch(re_str,'abc1'))

"""第一位数字或者下划线，后面是abc"""
re_str=r'[\d_]abc'
print(re.fullmatch(re_str,'_abc'))
print(re.fullmatch(re_str,'8abc'))


#2. [^]匹配不在中括号中出现的任意一个字符
"""匹配一个字符串 前三位是abc 第四位不是数字字符 也不是字符a 其他都可以"""
re_str = r'abc[^\da]'
print(re.fullmatch(re_str, 'abc_'))
print(re.fullmatch(re_str, 'abc8'))

#3. *匹配0次或者多次
"""匹配一个字符串 前面是0个或者多个数字字符 然后是abc"""
re_str=r'\d*abc'
print(re.fullmatch(re_str,'520abc'))
print(re.fullmatch(re_str, '520babc'))

"""
[0-9]:匹配1到9中任意一个数字字符
[a-z]:匹配任意一个小写字母
[A-Z]:匹配一个任意大写字母
[a-zA-Z]:匹配所有的字母
"""
print(re.fullmatch(r'[0-9]','5'))
print(re.fullmatch(r'[a-z]', 'd'))
print(re.fullmatch(r'[A-Z]','K'))
print(re.fullmatch(r'[a-zA-Z]', 'i'))

#写一个正则表达式，判断一个字符串是数字字符串（不能空船）

re_str=r'\d\d*'
re_str=r'[0-9][0-9]'
print(re.fullmatch(re_str,'45'))

#写一个正则表达式 检测一个字符串是否是合格的标识符（字母数字下划线组成 数字不开头）

re_str='[a-zA-Z]\w*'
print(re.fullmatch(re_str,'8bc'))


#4. +:匹配一次或者多次
"""匹配一个字符串,开头出现一次或者多个数字字符 然后再有0次或者多次数字 字母 下划线"""
re_str=r'\d+\w'
print(re.fullmatch(re_str,'1u78abc'))

#5. ?:匹配0次或者1次
re_str=r'[a-z]123'
print(re.fullmatch(re_str,'z123'))

#判断一个字符串是否是正整数字符串(除0)
re_str=r'[+]?[1-9]\d*'
print(re.fullmatch(re_str,''))

#5. {N}:匹配N次
"""前面是5个数字 然后是abc"""
re_str=r'\d{5}abc'
print(re.fullmatch(re_str, '12345abc'))
re_str='[123k]{3}abc'
print(re.fullmatch(re_str,'11kabc'))

#6.{N,}匹配大于N次
"""字符串前面至少三维数字 后面随意"""
re_str=r'\d{3,}.*'
print(re.fullmatch(re_str,'4545..:'))

#7. {m,n}至少匹配m次最少n次
"""密码要求：数字 字母组成 并且8-16位"""
re_str=r'[\da-zA-Z]{8,10}'
print(re.fullmatch(re_str,'sdfvbdfg'))

#8. \ 分支，
#匹配一个字符串，三个数字字符或者三个小写字母字符  相当于或运算
re_str=r'\d{3}|[a-z]{3}'
print(re.fullmatch(re_str,'123'))
print(re.fullmatch(re_str, 'asd'))


#9. ()匹配的时候是分组 让括号中的正则条件变成一个整体
re_str=r'(\w*)'
print(re.fullmatch(re_str, '1s_afxz'))
"""匹配一个字符串 abc整体重复三次"""
re_str=r'(abc){3}'
print(re.fullmatch(re_str,'abcabcabc'))

re_str=r'(\d\w[0-3]){2}'
print(re.fullmatch(re_str,'2s18d3'))

"""=====以下了解====="""
#10 *?重复任意次 然后尽可能少的重复
re_str=r'ba*?b'
print(re.match(re_str,'baabaa'))

#11.+?重复一次或多次 尽可能少的重复
re_str = r'b+?'
print(re.match(re_str,'bbbb'))

# 12.??重复一次或0次 尽可能少的重复
re_str = r'b*?'
print(re.match(re_str, 'b'))

#13{n,]?重复至少n次 尽可能少的重复
#14{m,n}？

三.正则表达式

正则中: .\ [] {} () * ? ^ $ | 这些字符有特殊意义 多以在正则表达式中 如果想要单纯的表达这些字符
需要在前面加 ''

注意：

1. • [] ^ \在中括号中可能是特殊符号
2. . {} () * + ? $ | 在中括号中不用加,来表示字符

   import re
   if __name__ == '__main__':
   re_str=r'\d+\.\d+'
   print(re.fullmatch(re_str, '12.89'))

   re_str = r'\d+[1\-3]\d+'  #中括号中匹配 1 或者 -  或者 3
   print(re.fullmatch(re_str, '12-89'))


   re_str=r'[\^]'#匹配字符^
   re_str=r'[\\]'#匹配字符\

   """
   1.\n --->匹配前面第n个组中的内容
   """
   re_str=r'([1-9][a-z]{2})\1'
   print(re.fullmatch(re_str,'9yu9yu'))

   re_str = r'([1-9][a-z]{2})n(\d)\1\2'
   print(re.fullmatch(re_str, '9hjn09hj0'))


   #练习：验证输入用户名和qq是否有效 并给出提示信息 要求：

   user=input('用户>>>>>>:')
   re_str=r'\w{6,20}'
   if re.fullmatch(re_str, user)!=None:
       print('用户名输入合法')
   else:
       print('用户名输入不合法')

   QQ=input('qq号>>>>')
   re_str=r'[1-9][0-9]{4,11}'
   if re.fullmatch(re_str,QQ)!=None:
       print('qq号输入有效')
   else:
       print('输入qq有误')





   ip=input('输入ip地址》》》》：')
   re_str=r'^(1\\d{2}|2[0-4]\\d|25[0-5]|[1-9]\\d|[1-9])\\.+(1\\d{2}|2[0-4]\\d|25[0-5]|[1-9]\\d|\\d)\\.+(1\\d{2}|2[0-4]\\d|25[0-5]|[1-9]\\d|\\d)\\.+(1\\d{2}|2[0-4]\\d|25[0-5]|[1-9]\\d|\\d)$'

   if re.fullmatch(re_str,ip)!=None:
       print('输入ip有效：')
   else:
       print('输入ip无效：')

四.re模块方法

import re
if __name__ == '__main__':
    #1.compile(正则字符串)将正则表达式字符串转换成正则表达式对象
    #2.转换成正则表达式对象后，可以通过对象调用相关的方法
    re_object=re.compile(r'\w{6,12}')
    print(re_object.fullmatch('asdfsdf'))
    print(re.fullmatch(r'\w{6,12}','afgsag'))

    #2.fullmath(正则表达式 字符串) 完全匹配 从字符串靠头匹配到结尾
    #返回值是匹配对象,如果匹配失败返回值None

    match=re.fullmatch('\w{3}','h3s')
    print(match)

    #a.获取匹配到的结果
    print(match.group())

    #b.获取匹配到的范围
    print(match.span())

    #c.获取匹配到的开始下标和结束下标
    print(match.start(),match.end())

    #d.获取被匹配的字符串（原字符串）
    print(match.string)
    #应用：判断一个字符串是否是某种字符串（判断账号 密码是否符合要求）


    #3.match(正则表达式 字符串) 不完全匹配 ，从字符串开头开始匹配 匹配到正则表达式对应的范围为止
    # 返回值是匹配对象,如果匹配失败返回值None
    match=re.match(r'\w{3}','aa3dfdff')
    print(match)
    print(match.group())
    print(match.string)

    #应用;判断一个字符串是否以某种字符串开头


    #4.search（正则表达式 字符串）在指定的字符串中查找查找某种字符串（以正则表达式来描述）
                #如果有多个满足条件的只获取第一个
    #返回值是匹配对象 如果找不到复核人要求的发挥None
    print(re.search(r'\d{2,}[a-z]','sha2m3n--3737834m27'))

    #应用：判断一个字符串中是否包含某种字符串

    #5.findall(正则表达式 字符串)去获取指定字符串中满足正则条件的所有的子串
    #返回值是列表，列表中是符合要求的字符串
    result=re.findall(r'\D\D+\D','a123hjkk6oji')
    result1 = re.findall(r'[a-zA-z](\d+)', '45a123hjkk+67ad789oji')
    print(result)
    print(result1)
    #注意：在通过正则表达式获取子串的时候，可以通过在正则表达式中添加括号，来约束获取的内容（只捕获括号中匹配到的内容）
            #在匹配的时候还是按照原正则表达式去查找
    #应用：字符串的提取

    #6.finditer(正则表达式 字符串)用法和findall一样 ，只是返回值的类型不一样
    #返回一个迭代器
    #注意;()中捕获部分无效
    result2 = re.finditer(r'[a-zA-z](\d+)', '45a123hjkk+67ad789oji')
    print(result2)
    for match in result2:
        print(match)

    #7.split(正则表达式 字符串) 按正则表达式匹配到的字符串进行切割
    #返回值是列表，列表元素就切割后被分段的字符串
    result3=re.split(r'\d+','fdsaf5gsag45sgg255')
    print(result3)

    result3 = re.split(r'[\[\]*\-]', 'fd*saf[5gs-ag4]5sg-g255')
    print(result3)

    #8.sub（正则表达式 新字符串 原字符串） 在原字符串中查找符合正则的子串，替换成新的字符串
    """将指定字符串中多有'sb'替换成'*'"""
    str1='你是一个大sb  一直都是大傻逼'
    result=re.sub(r'sb|傻|逼','*',str1)
    print(str1,result)