01 recode

1.匹配字符

.
\w,\W
\s,\S
\d,\D
[字符集]，[^字符集]
\b,\B,^,$

2.匹配次数

*,+,?,{M,N}，{M,},{,N},{N}

3.分之

|

4.分组

()
\数字 -- 重复前面第几个分组匹配到的内容

import re
def main():
    re_str = r'(\d\d)\.([a-z]{2,3})'
    print(re.fullmatch(re_str, '25.af'))

    result = re.findall(re_str, 'agsdsf23.df=sd2343.asd"df:da.fgd')
    print(result)

if __name__ == '__main__':
    main()

02贪婪

什么是非贪婪：在正则中控制匹配不确定次数的符号后边可以加?，来表示尽可能少的匹配
              在贪婪的时候，匹配是尽可能多的匹配
注意：尽可能的少是在能够匹配到的前提下尽可能少
*?
+?
??
{M,}?
{,N}?
{M,N}?

import re
def main():
    re_str = r'\d+'
    print(re.search(r'\d+', 'dfag21434==dsgdv'))
    print(re.search(r'\d+?', 'dfag21434==dsgdv'))


if __name__ == '__main__':
    main()

03re模块！！！

都在代码中

import re

def main():
    # 1. compile(正则表达式)  - 将正则表达式转换成正则对象
    """
    编译后可以直接通过对象调用相关的对象方法
    """
    re_object = re.compile(r'\d{3}')
    re_object.fullmatch('435')

    # 2. fullmatch(正则表达式，字符串)  -> 让字符串和正则表达式完全匹配，匹配成功返回匹配对象，匹配失败返回None
    """
    应用：检测字符串内容是否符合要求，例如：检测账号、密码、判断手机号、身份证号等是否合法
    """
    result = re.fullmatch(r'(\d{3})=([a-z]+)', '345=sdfw')
    print(result)

    # 匹配对象
    # 1）. span() - 匹配到的字符串在原字符串中的下标范围(结果是元祖)
    print('=====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', 'd4sdf23'))

    # 4. search(正则表达式，字符串) -> 在字符串中去匹配出第一个符合正则表达式的子串，匹配成功结果是匹配对象，否则是None
    print(re.search(r'[\u4e00-\u9fa5]{3}', 'saf后宫hou你好啊！df2我很好3'))

    # 5. split(正则表达式，字符串) -> 将字符串按照满足正则要求的子串进行切割（返回值是列表）
    print(re.split(r'\d+', 'sdf9sdf7g6677s====23nfdsaf'))

    # 6. sub(正则表达式，字符串1，字符串2) -> 将字符串2中能够和正则表达式匹配的子串替换成字符串1，产生一个新的字符串
    print(re.sub(r'\d+', '*', 'joi23hui3234kjds'))
    print(re.sub(r'傻逼|[傻草操艹]', '*', '你是傻逼吗？艹'))

    # 7. findall(正则表达式，字符串) -> 在字符串中获取满足正则表达式的所有的字符串（结果是列表）
    # 注意：如果正则表达式中有分组，直接获取到的是分组中匹配到的内容；如果有多个分组列表中的元素是元祖
    print(re.findall(r'\d+[a-z]', 'sdf78sdaf687adf87'))
    print(re.findall(r'(\d+)([a-z])', 'sdf78sdaf687adf87'))
    print(re.findall(r'(\d+)[a-z]', 'sdf78sdaf687adf87'))

    # 8. finditer(正则表达式，字符串) -> 在字符串中获取满足正则表达式的所有的子串（结果是迭代器，元素是匹配对象）
    result = re.finditer(r'\d+', 'lksjdf234sdf否定34')
    print(result)
    print(next(result))
    print(next(result).group())

    # 9. re.I  -> 忽略大小写
    # 匹配的约束条件是放在函数的flags参数中的
    print(re.fullmatch(r'[a-z]{2}', 'fD', re.I))

    # 练习：QQ用户名和QQ号正则
    re_str1 = r'[a-zA-Z0-9_]{6,20}'
    re_str2 = r'[1-9]\d{4-11}'

    print('========review=========================')

    result = re.fullmatch(r'[\d{2}a-z](ab)(c)\1', '4aBcAb', re.I)
    print(result)
    print(result.span())
    print(result.start(), result.end())
    print(result.group())
    print(result.group(1))
    print(result.group(2))
    print(result.groups())
    print(re.match(r'\d{2}a-z', '43a-zdjfege322=='))
    print(re.search('\d+?', 'hkjh23453ddsf=-=-=f234fsf'))
    print(re.split(r'[a-zA-Z_]{1,}', '哈哈WOsdf2344d-==v423ssd_23_23'))
    print(re.sub(r'傻子|傻', '宝器', '你是傻的啊！你怕不是个傻子哦！'))
    print(re.findall(r'[^0-9a-zA-Z]+', '今sdfg天_sdf又345是65-=-=-元气fb满dfg满df的一天'))
    print(re.findall(r'[^0-9a-zA-Z]+?', '今sdfg天_sdf又345是65-=-=-元气fb满dfg满df的一天'))
    result = re.finditer(r'[^0-9a-zA-Z]+', '今sdfg天_sdf又345是65-=-=-元气fb满dfg满df的一天')
    for item in result:
        print(item)
        print(item.group())


if __name__ == '__main__':
    main()