美文网首页
day17markdown总结

day17markdown总结

作者: DoubleKou | 来源:发表于2018-09-11 19:13 被阅读0次

    1.正则表达式

    from re import fullmatch, search, findall
    正则表达式就是用来检测字符串是否满足某种规则的工具
    例如:
    1.账号是手机号邮箱多少位由什么组成
    2.付款后,按时发,
    3.脏话替换等

    1.正则语法
    2.python对正则表达式的支持,,提供了一个内置模块:re
    3.fullmatch(正则表达式,字符串):判断整个字符串是否符合正表达规则

    =================1.单个字符==================
    1)匹配任意字符
    匹配一个字符串,只有以为字符并且字符是任意字符

    re_str = r'.'
    result = fullmatch(re_str, 'a')
    print(sesult)
    

    匹配一个字符串,只有两位字符并这每个字符都是任意字符

    re_str = r'..'
    result = fullmatch(re_str, 'an')
    print(result)
    

    匹配到一个字符串,前三位分别是abc,最后一位是任意字符

    re_str = r'abc.'
    result = fullmatch(re_str, 'abc%')
    print(result)
    

    2)\w匹配字母数字下划线
    匹配一个字符串,前三位分别是abc,最后两位是字母数字或者下划线

    re_str = r'abc\w\w'
    result = fullmatch(re_str, 'abc2g')
    print(result)
    

    3)\s匹配空白字符(空白指空格、制表符(\t)和回车(\n)等所有能产生空白的字符)
    匹配一个字符串,前三位是字母数字下划线,第四位是一个空白字符,最后一位是任意字符

    re_str = r'\w\w\w\s.'
    result = fullmatch(re_str, 'hu2\t?')
    print(result)
    

    4)\d 匹配一个数字字符
    匹配一个字符串,前三位是数字字符,最后一位是任意字符

    re_str = r'\d\d\d.'
    result = fullmatch(re_str, '782l')
    print(result)
    

    5)\b检测是否是单词边界(单词的开头、单词的结尾、单词和单词之间的标点空格等)
    注意:正则中遇到\b,匹配的时候先不管他,匹配成功后再回头看\b位置是否是单词边界

    re_str = r'when\b\swhere'
    result = fullmatch(re_str, 'when where')
    print(result)
    

    6)^检测字符串是否以给定的正则表达式开头
    匹配一个字符串,是否以两个数字字符开头

    re_str = r'\d\d'
    result = fullmatch(re_str, '23')
    print(result)
    

    7)$检测字符中是否以给定的正则表达式结束
    匹配一个字符串a数字,并且a数字是字符串的结尾

    re_str = r'a\d$'
    result = fulllmatch(re_str, 'a8')
    print(result)
    

    8)\W匹配一个非数字、字母、下划线的字符

    re_str = r'\W\w'
    result = fullmatch(re_str, '!a')
    print(result)
    

    9)\S匹配非空白字符

    re_str = r'\S\w\w\w'
    result = fullmatch(re_str, '@a3h')
    print(result)
    

    ======================2.匹配次数=======================
    1.[]匹配中括号中出现的任意字符
    注意:一个中括号只出现一个字符,第一位是a或者b或者c,后两位是数字

    re_str = r'[abc+]\d\d'
    result = fullmatch(re_str, '+67')
    print(result)
    

    注意:

    - 在正则中的中括号中的应用:如果将减号放到两个字符的中间代表的是谁到谁。如果想要表示'-'符号本身,就放在开头或者结尾
    [1-8]: 代表的字符集是:'1','2','3','4','5','6','7','8'
    [-18]或者[18-]: 代表的字符集是'1','8','-'
    要求一个字符串中的第一个是1-8中的一个,后面两位是小写字母
    re_str = r'[1-8][a-z][a-z]'
    result = fullmatch(re_str, '2hn')
    print(result)
    

    2.[^字符集]匹配不在[]字符集中的任意一个字符
    匹配一个四位的字符串,第一位不是大写字母也不是数字,后三位是abc

    re_str = r'[^A-Z\d]abc'
    result = fullmatch(re_str, '#abc')
    priint(result)
    

    3)*匹配0次或者多次
    匹配一个字符串,最后一位是b,b的前面有0个或者多个a

    re_str = r'a*b'
    print(fullmatch(re_str, 'aaab'))
    
      • 匹配1次或者多次(至少一次)
        判断一个字符串是否是无符号的正整数
    re_str = r'[1-9]+\d*'  # 10, 11, 100 ,1000
    print(fullmatch(re_str, '1010'))
    
    1. ? 匹配0次或者一次
    re_str = r'@?\d+'
    print(fullmatch(re_str, '@16723'))
    判断一个字符串是否是整数(包含正整数和负整数)
    +200, -120, 99, -1, 3, +4
    re_str = r'[+-]?[1-9]+\d*'
    print(fullmatch(re_str, '200'))
    
    1. {N} 匹配N次
    re_str = r'\d{3}'      # 匹配3位数字字符串
    re_str = r'[a-zA-Z]{3}'   # 匹配3位字母字符串
    print(fullmatch(re_str, 'aHh'))
    
    1. {N,} 至少匹配N次
    re_str = r'\w{4,}'
    print(fullmatch(re_str, 'hanc_123'))
    
    1. {,N} 最多匹配N次
    re_str = r'a{,4}b'  # 'b', 'ab', 'aab', 'aaab','aaaab'
    print(fullmatch(re_str, 'aaaab'))
    
    1. {M,N} 匹配至少M次,最多N次 (N>M)
    re_str = r'a{2,4}b'  # 'aab', 'aaab', 'aaaab'
    print(fullmatch(re_str, 'aaab'))
    

    ==============================3.分之和分组======================

    1. | 分之(相当于逻辑运算中的or)
      匹配一个字符串是三个字母或者是三个数字
    re_str = r'[a-zA-Z]{3}|\d{3}'
    print(fullmatch(re_str, 'abc'))
    '\d{3}[a-z]{2}'是分之中的第一个条件, '[A-F]{3}'是分之的第二个条件
    re_str = r'\d{3}[a-z]{2}|[A-F]{3}'
    print(fullmatch(re_str, 'ABC'))
    

    注意:正则中的分之有短路操作:如果使用|去连接多个条件,前面的条件已经匹配出结果,那么就不会使用后面的条件再去匹配了
    练习:写一个正则表达式,能够匹配出字符串中所有的数字(包括整数和小数)

    'abc12.5hhh60,30.2kkk9nn0.12'
    100, 89.89, 20.12, 0.23
    re_str = r'[1-9]\d*[.]?\d*|0[.]\d+'
    print()
    re_str = r'[1-9]\d*|\d+[.]\d+'
    re_str = r'\d+[.]\d+|[1-9]\d*'
    print(findall(re_str, 'abc12.5hhh60,30.2kkk9nn0.12'))
    
    1. 分组
      a.分组
      通过加()来对正则条件进行分组
      两位数字两位字母出现3次 ac23bn45hj34
    re_str = r'([a-z]{2}\d{2}){3}'
    print(fullmatch(re_str, 'ac23bn45hj34'))
    

    匹配一个字符串,按照一个数字一个字母的规律出现一次或者多次

    re_str = r'(\d[a-z])+'
    print(fullmatch(re_str, '9a2s3k4k9o'))
    

    b.重复
    可以通过\数字来重复匹配前面的分组中匹配的结果。数字的值代表前面的第几个分组

    re_str = r'(\d{2}[A-Z])=%\1\1'
    print(fullmatch(re_str,'23B=%23B23B'))
    
    re_str = r'(\d{3})-(\w{2})\1{2}\2'
    print(fullmatch(re_str,'123-aa123123aa'))
    

    c.捕获
    按照完整的正则表达式去匹配,只捕获()中的内容。只有在findall中有效

    re_str = r'a(\d{3})b'
    print(fullmatch(re_str, 'a786b'))
    print(findall(re_str, 'a786b'))
    

    正则中的转义

    1.正则表达式中的转义和字符串中的转义字符没有任何关系。
    在python中的字符串前加r阻止的是字符串转义,不能阻止正则表达式的转义
    2.在正则表达式中,可以通过在有特殊意义的符号前加\来表示符号本身
    + . * ? \ ( ) ^ $ |
    注意:

    a.- 只有在中括号中的两个字符之间才有特殊的意义
    b.如果特殊符号放到[]中作为字符集的内容,那么除了-在两个字符之间以外其他的都不需要转义
    c.\ 不管在哪里都需要转义, ^放在中括号的最前面需要转义
    

    例如:

    re_str = r'a\+'
    print(re.fullmatch(re_str, 'a+'))
    
    re_str = r'\+a'
    print(re.fullmatch(re_str, '+a'))
    
    re_str = r'\\w-a'
    print(re.fullmatch(re_str, '\w-a'))
    
    re_str = r'\(\d{3}'
    print(re.fullmatch(re_str,'(234'))
    
    re_str = r'\[abc\]'
    
    re_str = r'[\^.?*]mbc\\'
    print(re.fullmatch(re_str, '?mbc\\'))
    

    re模块

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

    re_str = r'\d+'
    re_object = re.compile(re_str)
    print(re_object)
    不转成对象,调用相应的函数
    re.fullmatch(re_str, '78hj')
    转换成对象,调用相应的方法
    re_object.fullmatch('78hj')
    

    2.match(正则表达式, 字符串) 和 fullmatch(正则表达式,字符串)
    match:判断字符串的开头是否能够和正则表达式匹配
    fullmatch: 判断整个字符串是否能够和正则表达式匹配
    返回值都是匹配结果,如果匹配成功返回匹配对象,否则返回None

    re_str = r'abc\d{3}'
    match1 = re.match(re_str, 'abc234abcdef')
    match2 = re.fullmatch(re_str, 'abc234')
    print(match1)
    print(match2)
    

    a.匹配到的范围。匹配结果字符的下标范围:(起始下标,结束下标) ---- 结束下标取不到
    print(match1.span())
    获取起点
    print(match1.start())
    获取终点
    print(match1.end())
    注意:group参数,用来指定分组对应的相应的结果

    re_str = r'(\d{3})\+([a-z]{2})'
    match1 = re.match(re_str, '234+hjaaaaaa')
    print(match1)
    print(match1.span())
    在匹配结果中,获取第1个分组的范围
    print(match1.span(1))
    在匹配结果中,获取第2个分组的范围
    print(match1.span(2))
    在匹配结果中,获取第2个分组的起始下标
    print(match1.start(2))
    

    b. 获取匹配结果对应的字符串
    print(match1.group())
    print(match1.group(1))
    print(match1.group(2))

    c. 获取被匹配的原字符串
    print(match1.string)
    3.search(正则表达式, 字符串)
    在字符串中去查找第一个满足正则表达式要求的子串,如果找到了就返回匹配对象,找不到返回None

    search1 = re.search(r'\d+aa', 'he9aallo 78aabc wolrd')
    print(search1)
    if search1:
        print(search1.span())
    

    练习:使用search将一个字符串中所有的数字字符串全部找到....
    '工资是10000元,年龄是18岁,身高是:180,颜值100分'

    str1 = '工资是10000元,年龄是18岁,身高是:180,颜值100分'
    re_str = r'[1-9]\d*'
    search1 = re.search(re_str, str1)
    while search1:
        print(search1.group())
        end = search1.end()
        str1 = str1[end:]
        search1 = re.search(re_str, str1)
    

    4.split(正则表达式,字符串)
    按满足正则表达式的子串去切割字符串返回值是列表

    str1 = '床前明月光,疑是地上霜。举头望明月,低头思故乡!'
    result = re.split(r'\W+', str1)
    print(result)
    

    5.sub(正则表达式,替换字符串,被替换的字符串)返回值是新的字符串

    word = '你丫是傻叉吗? 我操你大爷的. Fuck you'
    result = re.sub(r'傻叉|操|Fuck|煞笔', '*', word)
    print(result)
    

    6.findall(正则表达式, 字符串)
    获取字符串中所有满足正则表达式的子串返回值是列表
    注意:分组中的捕获效果在这儿有效

    result = re.findall(r'\d([a-z]+)', '安徽省1boy,and你好福建0action')
    print(result)
    

    相关文章

      网友评论

          本文标题:day17markdown总结

          本文链接:https://www.haomeiwen.com/subject/bkfpgftx.html