day15正则表达式

# -*- coding: utf-8 -*-
# @Author: KingJX
# @Date  : 2018/8/3 9:13
""""""

01-正则表达式的符号

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

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'))

    # 2. \w: 匹配一个字符是字母,数字,下划线
    re_str = r'\w'
    print(re.fullmatch(re_str, '_'))

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

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

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

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

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

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

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

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

    # 11. \B: 检测非边界
    re_str = r'\Babc'
    print(re.findall(re_str, 'sdjb abcs,sabc'))

输出结果:
<re.Match object; span=(0, 2), match='ab'>
<re.Match object; span=(0, 1), match='_'>
<re.Match object; span=(0, 3), match='a\tb'>
<re.Match object; span=(0, 3), match='789'>
<re.Match object; span=(0, 3), match='789'>
<re.Match object; span=(0, 3), match='asd'>
<re.Match object; span=(0, 3), match='The'>
['abc']
<re.Match object; span=(0, 2), match='!_'>
<re.Match object; span=(0, 2), match=';6'>
<re.Match object; span=(0, 2), match='a5'>
['abc']

02-正则表达式符号组合

if __name__ == '__main__':
    # 1. []: 匹配'[]'中出现的任意一个字符
    """
    匹配一个字符串前三位是abc,第四位是'1'或者'a'
    [0-9]: 匹配0,1,2,3,4,5,6,7,8,9中的任意一个字符
    [a-z]: 匹配任意一个小写字母
    [a-zA-Z]: 匹配所有字母
    """
    re_str = r'abc[1a]'
    print(re.fullmatch(re_str, 'abc1'))
    """第一位数字或下划线,后面是abc"""
    re_str = r'[\d_]abc'
    print(re.fullmatch(re_str, '9abc'))

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

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

    # 4. +: 匹配1次或者多次
    re_str = r'\d+\w*'
    print(re.fullmatch(re_str, '132abc'))

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

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

    # 6. {N}: 匹配N次
    """字符串前面5个数字,后面为abc"""
    re_str = r'\d{5}abc'

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

    # 8. {M,N}: 匹配最少M次,最多N次
    """密码要求:数字字母组成,并且8-16位"""
    re_str = r'[\da-zA-Z]{8,16}'
    print(re.fullmatch(re_str, 'fsd6g54654'))

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

    # 10. (): 匹配的时候,就是分组,让括号中的正则条件变成一个整体,进行整体操作

    # 写一个正则表达式,判断一个字符串是数字字符串
    re_str = r'\d\d*'
    print(re.fullmatch(re_str, '132416'))
    re_str = r'[0-9][0-9]*'
    print(re.fullmatch(re_str, '132416'))

    # 练习:检测命名规范
    re_str = r'[a-zA-Z_]\w*'
    print(re.fullmatch(re_str, 'fd58sd'))

    # 写一个正则表达式能有匹配一个分数(0-100)

输出结果:
<re.Match object; span=(0, 4), match='abc1'>
<re.Match object; span=(0, 4), match='9abc'>
<re.Match object; span=(0, 4), match='abc!'>
<re.Match object; span=(0, 6), match='132abc'>
<re.Match object; span=(0, 6), match='132abc'>
<re.Match object; span=(0, 4), match='a123'>
<re.Match object; span=(0, 6), match='+16151'>
<re.Match object; span=(0, 10), match='fsd6g54654'>
<re.Match object; span=(0, 3), match='123'>
<re.Match object; span=(0, 6), match='132416'>
<re.Match object; span=(0, 6), match='132416'>
<re.Match object; span=(0, 6), match='fd58sd'>

03-正则表达式

1.特殊符号转义
正则中：. \ [] {} () * + ? ^ $ | 这些字符有特殊意义，所以在正则表达式中，
       如果想要单纯表达这些字符，需要在前面加'\'; 
       
       
注意：1. -，[],^,\ 在中括号中可能是特殊的符号,需要加\
     2. . {} () * + ? $ |在中括号中可以不用加\,来表示字符
"""

import re

if __name__ == '__main__':
    re_str = r'\d+[1\-3]\d+'
    print(re.fullmatch(re_str, '12-89'))

    re_str = r'[\^]'  # 匹配 字符^
    re_str = r'[\\]'  # 匹配 字符\
    re_str = r'[\$]'
    re_str = r'[{}]'
    print(re.fullmatch(re_str, '{'))

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



    # 练习1.
    # 用户名必须由字母、数字或下划线构成且长度在6~20个字符之间
    re_str = r'\w{6,20}'
    #QQ号是5~12的数字且首位不能为0
    re_str = r'[1-9]\d{4,11}'

    # 练习2：IP地址是合法
    """
    x.x.x.x
    x: 1-255
    写一个正则表达式判断一个字符串是否是：1-255
    1-9
    10-99
    100-199
    200-249
    250-255
    """
    re_str = r'(([1-9]|[1-9]\d|1\d{2}|2[0-4]\d|25[0-5])\.){3}([1-9]|[1-9]\d|1\d{2}|2[0-4]\d|25[0-5])'
    print(re.fullmatch(re_str, '10.7.1.249'))

输出结果:
<re.Match object; span=(0, 5), match='12-89'>
<re.Match object; span=(0, 1), match='{'>
<re.Match object; span=(0, 9), match='9hjn09hj0'>
<re.Match object; span=(0, 10), match='10.7.1.249'>

04-re模块方法

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

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

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

    # 4.search(正则表达式, 字符串) 在指定的字符串中查找某种字符串(以正则表达式来描述)
    # 如果有多个满足条件的,只匹配第一个,如果找不到匹配要求的就返回None
    print(re.search(r'\d{2,}[a-z]', 'asa12d--465s64615'))
    # 判断一个字符串中是否包含某种字符串

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

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

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

    # 8.sub(正则表达式, 替换字符串, 原字符串) 在原字符串中查找符合正则的子串, 替换成新的字符串
    """将指定字符串中的所有'sb',替换成'*'"""
    str1 = 'sb!!!,FCsb'
    result = re.sub(r'sb', '*', str1)
    print(str1, result)