一、正则表达式的符号

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

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

import re

if name == 'main':
#注意：正则表达式的字符串前面，一般要加'r'来阻止转义。因为正则表达式的符号中很多带有反斜杠，其功能不是转义，而是表示特殊的意思捏

 #1. .：匹配一个任意的字符
   """匹配两个任意字符"""
   re_str = r'..'
   """匹配第一个字符是a，第二个字符是b的字符串"""
   re_str = r'ab'
   """匹配第一个字符是a，第二个字符是任意一个字符的字符串"""
   re_str = r'a.'
   print(re.fullmatch(re_str,'ab'))

结果

<re.Match object; span=(0, 2), match='ab'>

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

结果

<re.Match object; span=(0, 2), match='b_'>

#3. \s :匹配一个空白字符(空格，换行、制表符)
  """匹配第一个字符是a，第二个字符是空白，最后一个字符是b的字符串"""
  re_str = 'a\sb'
  print(re.fullmatch(re_str,'a\nb'))

结果

<re.Match object; span=(0, 3), match='a\nb'>

#4. \d :匹配一个数字字符
 re_str = r'\d\d\d'
 print(re.fullmatch(re_str,'234'))

结果

<re.Match object; span=(0, 3), match='234'>

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

结果

<re.Match object; span=(0, 3), match='jsh'>

#6. ^ :检测字符串开始(^The---匹配以The开头的区别)
 re_str = r'^The'
 print(re.fullmatch(re_str,'The'))

结果

<re.Match object; span=(0, 3), match='The'>

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

结果

['abc']

#8. \W:匹配非字母数字下划线
 re_str = r'a\Wb'
 print(re.fullmatch(re_str,'a@b'))

结果

<re.Match object; span=(0, 3), match='a@b'>

#9. \S:匹配非空白字符
    re_str = r'a\Sc'
    print(re.fullmatch(re_str,'abc'))

结果

<re.Match object; span=(0, 3), match='abc'>

#10 \D:匹配非数字字符
    re_str = r'\D\w'
    print(re.fullmatch(re_str,'a1'))

结果

<re.Match object; span=(0, 2), match='a1'>

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

结果

['abc']
<re.Match object; span=(0, 3), match='abc'>

二、正则表达式符号组合

import re
if name == 'main':

 #1. [] 匹配[]中出现的任意一个字符
    """匹配一个字符串，前三位是abc，第四位是字符1或者字符a"""
    re_str = r'abc[1a]'
    print(re.fullmatch(re_str,'abc1'))
    """第一位是数字或者下划线，后面是abc"""
    re_str = r'[\d_]abc'
    print(re.fullmatch(re_str,'1abc'))

结果

<re.Match object; span=(0, 4), match='abc1'>
<re.Match object; span=(0, 4), match='1abc'>

#2. [^]:匹配不在中括号中出现的任意一个字符
    """匹配一个字符串，前三位是abc，第四位不是数字字符也不是字符a的字符"""
    re_str = r'abc[^\da]'
    print(re.fullmatch(re_str,'abce'))
    """
    [0-9]:匹配0,1,2,3,4,5,6,7,8,9中的任意一个字符
    [a-z]:匹配任意一个小写字母
    [A-Z]:匹配任意一个大写字母
    [a-zA-Z]:匹配所有的字母
    """
    #写一个正则表达式，判断一个字符串是数字字符串
    re_str = r'\d\d*'
    re_str = r'[0-9][0-9]*'

    #写一个正则表达式，检测一个字符串是否是一个合格的标识符
    re_str = r'\D\w*'
    re_str = r'[a-zA-Z_]\w*'
    print(re.fullmatch(re_str,'ewd'))

结果

<re.Match object; span=(0, 4), match='abce'>
<re.Match object; span=(0, 3), match='ewd'>

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

结果

<re.Match object; span=(0, 7), match='1414abc'>

    #4.+：匹配一次或者多次
    """匹配一个字符串开头出现一次或者多次数字字符，然后再有0次或者多次数字字母下划线"""
    re_str = r'\d+\w*'

    #5. ?:匹配0次或者1次
    re_str = r'\[a-z]?123'

    #判断一个字符串是否是正整数
    re_str = r'[+]?[1-9]\d*'

    print(re.fullmatch(re_str,'12'))

结果

<re.Match object; span=(0, 2), match='12'>

    #5. {N}:匹配N次
    """前面五个数字，然后是abc"""
    re_str = r'\d{5}abc'
    re_str = r'[12ab]{3}abc'

    #6.{N,}:匹配大于等于N次
    """字符串前面至少三位数字"""
    re_str = r'\d{3,}.*'

    #7. {M,N}:匹配至少M次，最多N次
    """密码要求：数字、字母组成，并且8-12位"""
    re_str = r'[\da-zA-Z]{8,12}'

    #8.|:分支
    """匹配一个字符串，是三个数字字符或者是三个小写字符"""
    re_str = r'\d{3}|[a-z]{3}'
    print(re.fullmatch(re_str,'232'))

结果

<re.Match object; span=(0, 3), match='232'>

    #9. ():匹配的时候是分组，让括号中的正则条件变成一个整体
    """匹配一个字符串，abc整体出现3次"""
    re_str = r'(abc){3}'
    print(re.fullmatch(re_str,'abcabcabc'))


    """=========一下了解========="""
    #尽可能少，在能够匹配到的前提上尽可能少的重复

结果

<re.Match object; span=(0, 9), match='abcabcabc'>

    #10. *?: 重复任意次，尽可能少的重复

    re_str = 'a*?'
    print(re.match(re_str,''))

结果

<re.Match object; span=(0, 0), match=''>

    #11. +?: 重复一次或者多次，尽可能少的重复

    #12. ??: 重复0次或者一次，进可能少的重复

三、正则表达式的符号转义

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

注意：1. - [] ^ \ 在中括号中可能是特殊的字符
     2.. {} () * + ? $ | 在中括号中可以不用加\，来表示字符
     

import re
if __name__ == '__main__':
    re_str = r'[\^]'
    re_str = r'[\\]'
    re_str = r'[\$]'



    #1. \N -->匹配前面第N个组中匹配的内容

    re_str = r'\w{6,20}'
    re_str = r'[1-9]\d{4,11}'
    print(re.fullmatch(re_str,'234561235121'))

四、re模块方法

import re
if __name__ == '__main__':

  #1.compile 将正则表达式字符串转换成正则表达式对象
    #转换成正则表达式对象后，可以通过对象调用相关方法
    re_obce = re.compile(r'\w{6,12}')
    print(re_obce.fullmatch('asdxda'))

结果

<re.Match object; span=(0, 6), match='asdxda'>

    #2.fullmatch(正则表达式，字符串)：完全匹配，从字符串开头匹配到结尾
    #返回值是匹配对象，如果匹配失败返回时None
    match = re.fullmatch('\w{3}','eqw')
    print(match)
    #a.获取匹配到的结果
    print(match.group())
    #b.获取到的范围
    print(match.span())
    #c.获取匹配到的开始下标和结束下标
    print(match.start())
    print(match.end())
    #获取被匹配的字符串
    print(match.string)
    #应用：判断一个字符是否是某种字符串(判断账号、密码是否符合)

结果

<re.Match object; span=(0, 3), match='eqw'>
eqw
(0, 3)
0
3
eqw

    #3.match(正则表达式，字符串)：不完全匹配，从字符串开头开始，匹要求配<br/>
到正则表达式对应的范围为止
    # 返回值是匹配对象，如果匹配失败返回时None
    macth = re.match('\w{3}','')

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

    #4.search(正则表达式，字符串)：在指定的字符串中查找某种字符串（以正则表达式来描述）
    #如果有多个满足条件，只取第一个
    # 返回值是匹配对象，如果匹配失败返回时None
    print(re.search(r'\d{2,}[a-z]','sh23n--876nkj383'))

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

结果

<re.Match object; span=(2, 5), match='23n'>

    #5.findall(正则表达式，字符串)：去获取指定字符串中满足正则条件的所有的子串
    #返回值是列表，列表中是符合要求的字符串。没有满足要求的字符串，就返回空的列表
    result = re.findall(r'[a-zA-Z]\d+','12a123jkugkj345njkr')
    print(result)
    #注意：在通过正则表达式获取子串的时候，可以通过在正则表达式中添加括号来约束获取的内容
    #只获取括号中匹配到的内容
    #  匹配的时候还是按原正则表达式去查找

    #应用：字符串提取

结果

['a123', 'j345']

    #6.finaiter(正则表达式，字符串)：用法和findall一样，只是返回值类型不一样
    #返回一个迭代器，迭代器中的内容是匹配对象
    #注意：()捕获部分无效
    result = re.finditer(r'[a-zA-Z]\d+', '12a123jkugkj345njkr')
    for match in result:
        print(result)

结果

<callable_iterator object at 0x0000020E4D4563C8>
<callable_iterator object at 0x0000020E4D4563C8>

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

结果

['jfh', 'riuhf', 'hhr', 'rjhkfkjw']

    #8.sub(正则表达式，替换成新字符串，原字符串)：在原字符串中查找符合<br/>
正则的子串，替换成新的字符串
    """将指定字符串中所有'sb'替换成"*'"""
    str = '你好sb，你全家都是sbjiafafhak'
    result = re.sub(r'sb|全家','*',str)
    print(result)

结果

你好*，你*都是*jiafafhak