主要提供正则相关的方法

import re

1.什么是正则

'''
正则是字符串匹配的一种工具，拥有自己的语法。语法中主要包含各种符号的使用
'''

2.正则的语法

'''
re.fullmatch(正则表达式，字符串) - 检查字符串是否完全符合正则表达式的规则（完全匹配）
匹配成功返回匹配对象，匹配失败返回N
正则表达式 - Python中的正则表达式是写在引号中（单双引号），但是一般情况下会引号前加r
r'正则表达式'
'''
print('===========匹配符号==========')

1）普通字符 - 除了正则中有特殊功能或特殊意义以外的其他的所有字符

普通字符在正则中表示字符本身

表示一个字符串有三个字符，每个字符分别是abc

re_str = r'ac'
result = re.fullmatch(re_str, 'ac')
print(result)

2) . - 匹配任意字符

'''
正则中出现 . 的位置可以品牌任意字符
一个 . 只能匹配一个任意字符
'''

re_str = r'a..c'
result = re.fullmatch(re_str, 'a3-c')
print(result)

3)\w - 匹配字母、数字或者下划线

'''
一个\w只能匹配一个字符(只针对ascii码有效)
'''

re_str = r'a\w.c'
result = re.fullmatch(re_str, 'af3c')

4）\s - 匹配一个空白字符

'''
空白：空格、回车/换行、制表符
'''

result = re.fullmatch(r'aaa\sf2', 'aaa\nf2')
print(result)

5)\d - 匹配一个数字字符

6）\大写字母 - 匹配非\小写字母匹配的内容

'''
\W - 匹配非数字、字母或者下划线
\S - 匹配非空白字符
\D - 匹配非数字字符
'''

7)[] - 匹配字符集

'''
a.普通用法
[字符集] - 匹配字符集中的任意一个字符
[ad] - 匹配一个字符是a或者d
[\davc] - 匹配一个字符是数字或者a或者v或者c
b.表示范围的字符集: [字符1-字符2] - 从字符1到字符2中的任意一个字符，注意字符2的编码值必须是大于等于字符
[5-9]
[a-z]
[a-zA-Z] - 匹配任意一个字母
[a-zA-Z\d] - 匹配字母数字
c.反向选中：[^字符集] - 选中字符集中以外的其他的任意的一个字符
'''

result = re.fullmatch(r'[^abc]', '.')
print(result)

print('==========检测符号==========')

一个匹配符号必须对应一个具体的字符；检测符号只是对符号所在的位置进行检查，不会影响字符串长度

1）\b - 检测是否是单词边界

'''
单词边界：一切可以将两个单词区分开的符号都是单词边界，单词开头，单词结尾，空白，标点符号
'''

匹配一个字符串是'howare',然后检测w的后面是否是单词边界

print(re.fullmatch(r'how\b are', 'how are'))

2) ^ - 检测 ^ 所在的位置是否是字符串开头

3） $- 检测$ 所在的位置是否是字符串结尾

贪婪和非贪婪

'''
,+,?,{}对应匹配次数是贪婪；在匹配次数不确定的时候才有贪婪与非贪婪的区分
在匹配次数不确定的符号后面加？，就会变成非贪婪：？，+？，？？，{M,N}?,
贪婪：在匹配成功的前提下尽可能多的匹配
非贪婪：在匹配成功的前提下尽可能少的匹配
'''

result = re.search(r'.+b', '1312abe121ab==')
print(result)
result = re.search(r'.+?b', '1312abe121ab')
print(result)

| 分支

'''
正则表达式1|正则表达式2
'''

（） - 分组

'''
1）分组 - 将正则的中的一部分看成一个整体进行操作
2）重复 - 添加分组后可以在分组的后面通过\M来重复前面第M个分组匹配到的结果
'''

print(re.fullmatch(r'(\d+)aad\1', '223aad223'))

转义符号 - 在正则符号前加\让符号的功能消失

'''
正则中的转义符号和字符串的转义字符是两回事
独立的特殊符号放在[]中特殊意义会自动消失，但是' - '，' [] '
'''

print(re.fullmatch(r'\.ad', '.ad'))
import re

print('=============匹配次数=============')

1.匹配次数

1) * - 匹配0次或多次

"""
字符* - *前的字符出现0次或者多次

r'a' - '','a','aa', 'aaa', 'aaaa',...
r'\d' - '', '1', '34', '11892'
r'[abc]*' - '', 'a', 'ab', 'abbc', 'aaccbbb'
"""

print(re.fullmatch(r'a\d*b', 'a9888723b'))
print(re.fullmatch(r'a\d*b', 'ab'))

2) + - 匹配1次或多次

print(re.fullmatch(r'a\d+b', 'ab'))  # None
print(re.fullmatch(r'a\d+b', 'a8232323b'))

3) ? - 匹配0次或1次

print(re.fullmatch(r'[+-]?\d+', '-293'))

4) {}

"""
{N} - 匹配N次
{M,N} - 匹配M到N次
{M,} - 匹配至少M次
{,N} - 最大匹配N次
"""

print(re.fullmatch(r'a{3}123', 'aaa123'))
print(re.fullmatch(r'a{2,5}123', 'aaa123'))
print(re.fullmatch(r'\d{3,}', '2238902324'))
print(re.fullmatch(r'\d{,3}', '219'))

练习: 验证输入用户名和QQ号是否有效并给出对应的提示信息

要求：

用户名必须由字母、数字或下划线构成且长度在6~20个字符之间

QQ号是5~12的数字且首位不能为0

result = re.fullmatch(r'[\da-zA-Z_]{6,20}', 'huashd920')
if result:
    print('用户名合法')
else:
    print('用户名不合法')


result = re.fullmatch(r'[1-9]\d{4,11}', '43232333')
if result:
    print('QQ合法')
else:
    print('QQ不合法')

2.贪婪和非贪婪

"""
*,+,?,{}对应匹配次数是贪婪; 在匹配次数不确定的时候才有贪婪和非贪婪的区分
在匹配次数不确定的符号后面加?,就会变成非贪婪: *?, +?, ??, {M,N}?, {M,}?, {,N}?

贪婪：在匹配成功的前提下，尽可能多的匹配
非贪婪: 在匹配成功的前提下，尽可能少的匹配
"""

result = re.search(r'.+b', '123aabcccaabdddb====')
print(result)    # 123aabcccaabdddb

result = re.search(r'.+?b', '123aabcccaabdddb====')
print(result)   # 123aab

result = re.search(r'a+?b', 'aab===')
print(result)

# 练习: 获取所有name对应的值
with open('files/data', encoding='utf-8') as f:
    content = f.readline()
    names = re.findall(r'"name":"(.+?)"', content)
    print(len(names), names)

3. | - 分之

"""
正则表达式1|正则表达式2
"""

print(re.fullmatch(r'\d{3}|[a-zA-Z]{3}', 'asd'))

4. () - 分组

"""

分组 - 将正则中的一部分看成一个整体进行操作
重复 - 添加分组后，可以分组的后面通过\M来重复前面第M个分组匹配到的结果
"""

需求: 一个字符串最开头是三个数字或者三个小写字母，后面全是大写字母

# 233KKSSK, abcJKJKJSKJDKJFKD
print(re.fullmatch(r'(\d{3}|[a-z]{3})[A-Z]+', 'ahsKLSA'))

# 23:45:67:78:67:89
print(re.fullmatch(r'(\d\d:)+\d\d', '34:54:34:67:90:12'))

# 23abc23, 100abc100, 39abc39  -> 匹配成功
# 23abc12  -> 匹配失败
print(re.fullmatch(r'(\d+)abc\1', '100abc100'))
print(re.fullmatch(r'(\d+)([a-z]+)=\2([abc]{3})=\1{2}', '23ac=acaaa=2323'))

5. 转义符号 - 在正则符号前加,让符号的功能消失

"""
正则中的转义符号和字符串的转义字符是两回事儿

独立的特殊符号放在[]中特殊意义会自动消失, 但是-,[]...
"""

re_str = r'\.abc'
print(re.fullmatch(re_str, '=abc'))

# 1+3
re_str = r'\d\+\d\\w'
print(re.fullmatch(re_str, '2+3\w'))


re_str = r'[.+*]abc[?]'   # .、+、*、?表示本身
print(re.fullmatch(re_str, '+abc?'))

# re_str = r'[a\-z]abc'
re_str = r'[az-]abc'
print(re.fullmatch(re_str, '-abc'))

re_str = r'[a\]^]abc'
print(re.fullmatch(re_str, ']abc'))

1.创建正则对象(了解)

"""
compile(正则表达式) - 根据正则表达式创建正则对象
"""

re_obj = compile(r'\d{3}')

print(fullmatch(r'\d{3}', '823'))
print(re_obj.fullmatch('234'))

2. 匹配

"""
fullmatch(正则表达式, 字符串) - 让整个字符串和正则表达式进行匹配
match(正则表达式, 字符串) - 匹配字符串开头

返回值：匹配成功是匹配结果对象，匹配失败是None
"""

result = fullmatch(r'\d{3}[a-z]{4}', '234jkka')
print(result)

result = match(r'(\d{3})([a-z]{4})', '789hsjd三家分晋看jshjdh')
print(result)

匹配结果

1)匹配结果对应的字符串

"""
匹配对象.group() - 获取整个正则匹配到的结果
匹配对象.group(N) - 获取第N个分组匹配到的结果
"""

print(result.group())
print(result.group(1))   # 取第一个分组的结果
print(result.group(2))      # 取第二个分组的结果

2)获取匹配位置

"""
匹配对象.span(group=0)
匹配对象.start(group=0)
匹配对象.end(group=0)
"""

print(result.span(1))    # 取第一个分组匹配到的位置
print(result.start(1))
print(result.end(2))

3)获取原字符串

print(result.string)

3.查找

"""
search(正则表达式,字符串) - 匹配出字符串中第一个满足正则表达式的子串,结果是匹配对象

findall(正则表达式,字符串) - 获取字符串中满足正则表达式的所有的子串；结果是列表，列表中元素是字符串

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

result = search(r'\d{3}', 'how34,jks789lsoos009,.sdf9822')
print(result)

result = findall(r'\d{3}', 'how34,jks789lsoos009,.sdf9822')
print(result)    # ['789', '009', '982']

result = findall(r'(\d{3})', 'how34d,jks789asoos009,.sdf9822a==sd')
print(result)   # ['789', '822']

result = findall(r'(\d{3})([a-z]{2,})', 'how342ddfb,jks789aasoos009,.sdf9822ad==sd')
print(result)   # [('342', 'ddfb'), ('789', 'aasoos'), ('822', 'ad')]


result = finditer(r'(\d{3})([a-z]{2,})', 'how342ddfb,jks789aasoos009,.sdf9822ad==sd')
print(result)
print(next(result))

4.切割

"""
split(正则表达式, 字符串) - 按照满足正则表达式的子串对字符串进行切割。返回列表
"""

str1 = 'aaa9bbb0ccc90ddd87eee123fff'
# print(str1.split('9'))
print(split(r'\d+', str1))

5.替换

"""
sub(正则表达式, 字符串1, 字符串2, 替换次数=0) - 将字符串2中满足正则表达式的子串替换成字符串1
替换次数是0的时候全部替换
"""

str1 = 'aaa9bbb0ccc90ddd87eee123fff'
new_str = sub(r'\d+', '+', str1)
print(new_str)    # aaa+bbb+ccc+ddd+eee+fff

new_str = sub(r'\d+', '+', str1, 2)
print(new_str)   # aaa+bbb+ccc90ddd87eee123fff


result = search(r'abc', 'hAbCjsfabckjks', flags=IGNORECASE)
print(result)

Day17-总结