正则表达式

1.正则表达式就是一种用来做字符串匹配的工具，通过不同的符号匹配不同的字符

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

"""__author__ == sxc"""



from re import fullmatch, search

def main():
    # 0    普通字符(代表字符本身)
    # 匹配一个字符串，只有三个字母，每个字符分别是abc,不能改变顺序和增加位数
    re_str = r'abc'
    result = fullmatch(re_str, 'abc')
    print(result)

    # 1    .(匹配任意字符)
    # 注意: a.一个点代表一个字符
    # *****b.不能匹配 \n*****
    # 匹配一个字符串，只有三个字母，第一个字符是a，第二字符是任意字符，第三个字符是c
    re_str = r'a.c'
    result = fullmatch(re_str, 'a\rc')
    print(result)

    # 2    \w(字母数字下划线) 也可以匹配中文
    # 匹配一个字符串，第一个字符是任意字符，第二第三是字母数字下划线
    re_str = r'.\w\wabc'
    result = fullmatch(re_str, 'a宋_abc')
    print(result)

    # 3    \s(匹配空白字符)
    # 所有能产生空白对字符 ，空格制表符，换行
    re_str = r'\w\w\s\w'
    result = fullmatch(re_str, 'aa\na')
    print(result)

    # 4    \d(匹配数字字符)
    # 匹配一个字符串，三个字符都是数字字符
    re_str = r'\d\d\d'
    result = fullmatch(re_str, '123')
    print(result)

    # 5    \b(检测单词边界)
    # a.检测正则表达式中\b所在的位置是否是单词边界
    # b.所有可以将两个单词区分开的符号都是单词边界，例如 空格,缩进,标点符号,单词开头和结尾也是
    # 匹配一个字符串内容是'how are'并且要求字符a的前面是番茨边界
    # 注意:\b不是匹配符号，不会匹配出一个字符，只是家呢所在位置是否满足要求
    re_str = r'\bhow\b,are'
    result = fullmatch(re_str, 'how,are')
    print(result)

    print(fullmatch(r'\d\d\d','233'))
    print(search(r'\b\d\d\d\b','adada233.adada'))
    print(search(r'\b\d\d\d\b', 'adada 233.adada'))

    # 6    ^(检测字符串开头）
    # 匹配一个字符串是三个数字字符，且第一个字符所在位置是字符串开头
    re_str = r'^\d\d\d'
    result = search(r'\d\d\d', 'adad789')
    result2 = search(re_str, '123asdasda')
    result3 = search(re_str, 'asda123')
    print(result)
    print(result2)
    print(result3)

    # 7    $(检测字符串结尾)
    # 匹配一个字符串是三个数字字符最后一个字符串后面的字符串是字符串结尾
    re_str = r'\d\d\d$'
    result = search(re_str, 'asdasd777')
    print(result)

    # 8    \B(检测非单词边界)
    re_str = r'abc\B123'
    result = fullmatch(re_str, 'abc123')
    print(result)
    
    # 9    \W(匹配非数字字母下划线中文)

    # 10   \S(匹配非空白字符)

    # 11   \D(匹配非数字字符)

    # 12   [字符集](匹配字符符集中)
    # a.普通用法

    # b.表示范围
    # [1-9]
    # [a-z]
    # [A-Z]
    # [a-zA-Z]
    # [a-zA-Z\d_]
    re_str = r'[a-zA-Z\d_]'
    result = fullmatch(re_str, '_')
    print(result)

    # 13   [^字符集] - 匹配配有在字符集中的其他
    re_str = r'[^abc]123'
    result = fullmatch(re_str, 'd123')
    print(result)
    # 14 转义符号
    # 正则中也可以在特殊符号前加'\'来符进行转义
    re_str = r'\^\d\d\.\d\d\\b'
    print(fullmatch(re_str, r'^23.45\b'))
    # -, ^ 在[]内有特殊意义,要表示其本色就不要将^放开头不要将-放在两个字符之间
    print(fullmatch(r'[.*^-]', '*'))

if __name__ == '__main__':
    main()
结果如下:
<_sre.SRE_Match object; span=(0, 3), match='abc'>
<_sre.SRE_Match object; span=(0, 3), match='a\rc'>
<_sre.SRE_Match object; span=(0, 6), match='a宋_abc'>
<_sre.SRE_Match object; span=(0, 4), match='aa\na'>
<_sre.SRE_Match object; span=(0, 3), match='123'>
<_sre.SRE_Match object; span=(0, 7), match='how,are'>
<_sre.SRE_Match object; span=(0, 3), match='233'>
None
<_sre.SRE_Match object; span=(6, 9), match='233'>
<_sre.SRE_Match object; span=(4, 7), match='789'>
<_sre.SRE_Match object; span=(0, 3), match='123'>
None
<_sre.SRE_Match object; span=(6, 9), match='777'>
<_sre.SRE_Match object; span=(0, 6), match='abc123'>
<_sre.SRE_Match object; span=(0, 1), match='_'>
<_sre.SRE_Match object; span=(0, 4), match='d123'>
<_sre.SRE_Match object; span=(0, 8), match='^23.45\\b'>
<_sre.SRE_Match object; span=(0, 1), match='*'>

import re


def main():
    # 1. *(匹配0次或者多次)
    # 字符* - 指定的字符出现0次或者多次(这的字符可以是正则符号也可以是普泰字符)
    #    a* a 出现0次或者多次
    # \d* - 任意数字出现0次或者多次
    # [a-z]* 任意小写字母出现0次或者多次

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

    # 123面前有0个或者多个数字字符
    re_str = r'\d*123'
    print(re.fullmatch(re_str, '1231231231123'))

    # 2 +(匹配1次或者多次)
    re_str = r'a+123'
    print(re.fullmatch(re_str, 'a123'))
    print(re.fullmatch(re_str, '123'))

    # 3 ?(匹配0次或者1次)
    re_str = r'\+?abc'
    print(re.fullmatch(re_str, '+abc'))

    # 匹配所有的整数数字字符串
    re_str = r'[+-]?[1-9]\d*'
    print(re.fullmatch(re_str, '-123'))

    # 4 {}
    # {M,N}匹配M到N次
    # {M,}
    # {,N]
    # {N}
    print(re.fullmatch(r'a{2,5}','aaaaa'))

    # 密码要求6-16并且只能是字母数字
    print(re.fullmatch(r'[a-zA-z\d]{6-16}','3u2222'))

if __name__ == '__main__':
    main()

结果如下:
<_sre.SRE_Match object; span=(0, 3), match='123'>
None
<_sre.SRE_Match object; span=(0, 13), match='1231231231123'>
<_sre.SRE_Match object; span=(0, 4), match='a123'>
None
<_sre.SRE_Match object; span=(0, 4), match='+abc'>
<_sre.SRE_Match object; span=(0, 4), match='-123'>
<_sre.SRE_Match object; span=(0, 5), match='aaaaa'>
None

import re
def main():
    # 表达式1|表达式2|表达式3 - 先用表达式1去匹配,匹配失败再用后面对去匹配
    re_str = r'[a-z]{3}|\d{3}'
    print(re.fullmatch(re_str,'abc'))

    # 2()分组 - 将括号里对内容看成一个整体
    # a.(abc){2} -->abcabc
    #    abc{2}  -->abcc

    # b.分组重复,在有分组对正则表达式中,可以在后面通过'\数字'来重复前边第几个分组匹配到对内容
    # (\d{2})abc\1  --> 78abc78
    # \1 就是前面第一个分组

    re_str = r'(\d{2})a(\d{3})bc\1'
    # \1 重复必须得和前面的一样
    print(re.fullmatch(re_str,'34a123bc34'))

if __name__ == '__main__':
    main()
结果如下:
<_sre.SRE_Match object; span=(0, 3), match='abc'>
<_sre.SRE_Match object; span=(0, 10), match='34a123bc34'>