总结Day17_正则表达式

===正则表达式===

1.什么是正则表达式(语法通用)

  正则就是一种用来做字符串匹配的工具,通过不同的符号匹配不同的字符

2.python对正则表达式的支持

  通过re模块提供相应支持正则表达式的方法
  a.fullmatch(正则表达式, 字符串) --> 用正则表达式来和指定字符串进行匹配，如果匹配成功返回匹配对象，匹配失败返回None
  python正的正则表达式是写在字符串中的，但是一般情况下会在最前面加r/R

0. 普通字符(代表字符串本身)

  匹配字符串,只有三个字符,每个字符分别是a,b,c

    re_str = r'abc'
    result = fullmatch(re_str, 'abc')

1. (匹配任意字符)

  注意:a.一个.代表一个字符
     b.不能匹配\n

# 匹配一个字符串,只有三个字符,第一个是a,第二个是任意字符,最后一个是c
    re_str = 'a.c'
    result = fullmatch(re_str, 'anc')
    print(result)

2.\w(匹配字母、数字、下划线、中文)

  注意:a.也可以匹配中文
     b.一个\w只能匹配一个字符

    # 匹配一个字符串,第一个是任意字符,第二个和第三个是字母,数字或_,最后三个是abc
    re_str = r'.\w\wabc'
    result = fullmatch(re_str, 'o9habc')
    print(result)

3.\s(匹配空白字符)

  空白字符:指的是所有空白字符,包括空格,制表符,换行等

    # 匹配一个字符,前两个是字母、数字、下划线或中文，第三个字符是空白，最后一个字符是是任意字符
    re_str = r'\w\w\s\w'
    result =fullmatch(re_str, 'aa 2')
    print(result)

4.\d(匹配数字字符)

    # 匹配一个字符串有三分字符,每个字符都是数字字符
    re_str = r'\d\d\d'
    result = fullmatch(re_str, '380')
    print(result)

5.\b(检测单词边界)

  检测正则表达式中\b所在的位置是否是单词边界
  b.单词边界:所有可以将单词区分开的符号都是单词边界,例如:空格,缩进,标点符号等
  注意:\b不是匹配符号,不会匹配出一个字符,只是检测所在的位置是否满足要求

    # 匹配一个字符串的内容是'how are',并且要求字符'a'的前面是单词边界
    re_str = r'how,\bare\b'
    result = fullmatch(re_str, 'how,are')
    print(result)

6.^(检测字符串开头)

    # 匹配一个字符串是三个数字字符,并且第一个字符所在位置是字符串开头
    re_str = '^\d\d\d'
    result = search(re_str, 'sdfg132sfsd')
    print(result)
    result = search(re_str, '132sfsd')
    print(result)

7.$(检测字符串结尾)

    # 匹配一个字符串是三个数字字符,并且最后一个字符的后面是字符串结尾
    re_str = '\d\d\d$'
    result = search(re_str, 'sdfg132sfsd')
    print(result)
    result = search(re_str, 'sdfg132')
    print(result)

8. \B(检测非单词边界)

    re_str = r'acb\B123'
    result = search(re_str, 'acb123')
    print(result)

9. \W(任何非单词字符)

10. \S(非空白字符)

11. \D(非数字字符)

12. [字符集](匹配字符集中的任意一个字符)

  a.普通用法
  注意:一个[]代表一个字符
  [字符集] - 匹配字符集的任意一个字符
  b.表示范围
  [字符1-字符2] - 匹配字符1到字符2中所有的字符。要求字符1的编码值要小于字符2的编码值
  [1-9] - 数字1-9
  [a-z] - 所有小写字母
  [A-Z] - 所有大写字母
  [a-zA-Z] - 所有字母
  [a-zA-Z\d_] - 数字字母下划线

    # 匹配一个字符串有4个字符,第一个字符是'a'或者'b'或者'c',后边的是123
    re_str = r'[abc]123'
    result = fullmatch(re_str, 'b123')
    print(result)

    # 匹配一个字符串有4个字符,第一个字符是数字1-9中的任意一个;最后一个字符是任意小写字母;中间两个是任意数字
    re_str = r'[1-9]\d\d[a-z]'
    result = fullmatch(re_str, '111d')
    print(result)

13. [^字符集] - 匹配没有在字符集中的其他任意字符

  注意: ^{放在[]的最前面才表示匹配不在字符集的其他任意字符;}如果不放在[]的最前面,就表示^本身

14. 转义符号

  a.正则中也可以通过在特殊符号前加'\'来对转义符号进行转义
  b.除了在中括号中有特殊意义的符号,其他符号放在[]中也是表示符号本身
  - :在中括号中的两个字符之间表示谁到谁;如果想要表示它本身就不要放在两个字符之间
  ^ :在括号的最前面有特殊意义;如果想要表示它本身就不要放在最前面
  []:在中括号里表示[],要加\
  注意:转义字符是字符串中的概念
     转义符号是正则表达式的概念

    re_str = r'\d\d.\d\d'
    print(fullmatch(re_str, '23.45'))

===匹配次数===

1. *(匹配次数0次或多次)

  字符* - 指定的字符出现0次或多次(这儿的字符可以是正则符号,也可以是普通字符)
  a* - a出现0次或多次
  \d* - 任意数字出现0次或多次
  [a-z]* - 任意小写字母出现0次或多次

re_str = r'a*123'
print(re.fullmatch(re_str, 'aaaa123'))

2.+(匹配1次或多次)

re_str = r'a+123'
print(re.fullmatch(re_str, 'aaaa123'))

3.?(匹配0次或1次)

# 练习:写一个正则表达式能够匹配所有的整数字符串

# re_str = r'\-?[1-9][0-9]*'
re_str = r'[+-]?[1-9]\d*'
print(re.fullmatch(re_str, '16646046'))

4.{}

  {M,N} - 匹配M到N次(最少M次,最多N次)
  {M,} - 至少M次
  {,N} - 最多N次
  {N} - N次

===分支和分组===

1. |(分支)

  表达式1|表达式2|表达式3 - 先用表达式1匹配,成功就直接成功;不成功就用表达式2匹配,不成功就表达式3,...以此类推
  (3个表达式中有一个成功就成功,否则就失败)

2. ()(分组)

  a.分组 - 将括号里面的内容当做一个整体
(abc){2} ---> abcabc
  b.分组重复 - 在有分组的正则表达式中通过\数字来重复前面几个部分重复的次数

===python正则函数===

1. compile(正则表达式) -> 将正则表达式转换成正则对象

  编译后可以直接通过对象调用相关的对象方法

re_object = re.compile(r'\d{3}')
re_object.fullmatch('432')

2. fullmatch(正则表达式, 字符串) -> 让字符串和正则表达式完全匹配，匹配成功返回匹配对象，匹配失败返回None

  应用：检测字符串内容是否符合要求,例如：检测账号、密码、判断手机号、身份证号等是否合法

result = re.fullmatch(r'(\d{3})=([a-z]+)', '342=sjaks')
print(result)

  匹配对象
  1).span() - 匹配到的字符串在原字符串中的下标范围(结果是元素)

print(result.span())   # 获取整个正则表达式匹配到的内容的范围
# start, end = result.span()
# print(start, end)

print(result.span(1))  # 获取正则表达式中第一个分组匹配到的内容的范围
print(result.span(2))  # 获取正则表达式中第二个分组匹配到的内容的范围

  2). start()和end() - 匹配到的字符串在原字符串中的开始下标和结束下标

print('====start名，end====')
print(result.start(), result.end())
print(result.start(1), result.start(2))

  3). group() - 获取匹配到的字符串(结果是字符串)

print(result.group())   # 获取整个正则匹配到的字符串
print(result.group(1))  # 获取第一个分组匹配到的字符串
print(result.group(2))  # 获取第二个分组匹配到的字符串
print(result.groups())  # 同时获取所有分组匹配到的字符串(结果是元祖)

  4). string - 获取原字符串

print(result.string)

3.match(正则表达式,字符串) -> 让字符串的开头和正则表达式进行匹配，匹配成功结果是匹配对象，否则是None

print(re.match(r'\D\d', 's3skjkjks'))

4.search(正则表达式,字符串) -> 在字符串中去匹配出第一个符合正则表达式的子串, 匹配成功结果是匹配对象,否则是None

print(re.search(r'[\u4e00-\u9fa5]{3}', 'hsj后视ss023你好吗,skss上的30s'))

5.split(正则表达式,字符串) -> 将字符串按照满足正则要求的子串进行切割(返回值是列表)

print(re.split(r'\d+', 'asj38jkas0093kjsj78kajs89==asdfj3jkkss'))

6.sub(正则表达式,字符串1, 字符串2) -> 将字符串2中能够和正则表达式匹配的子串替换成字符串1，产生一个新的字符串

print(re.sub(r'\d+', '*', 'jsj93jksj93j5a45s3s是看得见'))
print(re.sub(r'傻逼|[傻艹草操]', '*', '你是傻逼吗？艹!'))

7.findall(正则表达式, 字符串) -> 在字符串中获取满足正则表达式的所有的子串(结果是列表)

  注意: 如果正则表达式中有分组，直接获取到的是分组中匹配到的内容; 如果有多个分组列表中的元素是元祖

print(re.findall(r'\d+[a-z]', 'sjh83bkss93ksjhf9922'))
print(re.findall(r'(\d+)[a-z]', 'sjh83bkss93=sjhf9922'))
print(re.findall(r'abc(\d{2}|[A-Z]{2})', '=-aaabc73kkjabcKJL=3'))

8.finditer(正则表达式, 字符串) -> 在字符串中获取满足正则表达式的所有的子串(结果是迭代器,元素是匹配对象)

result = re.finditer(r'(\d+)[a-z]', 'sj8khk83jks数据310sj=sd')
print(result)
print(next(result).group())

9.re.I -> 忽略大小写

  匹配的约束条件是放在函数的flags参数中的

    print(re.fullmatch(r'[a-z]{2}', 'SA', re.I))

字符	描述	示例
.	匹配除“\n”之外的任何单个字符。
\b	匹配一个单词边界，也就是指单词和空格间的位置。
\B	匹配非单词边界。
\d	匹配一个数字字符。
\D	匹配一个非数字字符。
\s	匹配任何空白字符，包括空格、制表符、换页符等等。
\S	匹配任何非空白字符。
\w	匹配包括下划线的任何单词字符。
\W	匹配任何非单词字符。
x|y	匹配x或y。
[]xyz]	字符集合。
[^xyz]	负值字符集合。匹配未包含的任意字符。
[a-z]	字符范围。匹配指定范围内的任意字符。
[^a-z]	负值字符范围。匹配任何不在指定范围内的任意字符。
^	匹配输入字符串的开始位置。
$	匹配输入字符串的结束位置。
*	匹配前面的子表达式零次或多次。
+	匹配前面的子表达式一次或多次。
?	匹配前面的子表达式零次或一次。
{n}	n是一个非负整数。匹配确定的n次。
{n,}	n是一个非负整数。至少匹配n次。
{n,m}	m和n均为非负整数，其中n<=m。最少匹配n次且最多匹配m次。