from re import fullmatch, search, findall

1. 什么是正则表达式

正则表达式是处理字符串的工具，通过不同的正则符号来描述字符串的规则

1.1 fullmatch

fullmatch(正则表达式, 字符串) - 查看字符串和正则表达式是否匹配，如果不匹配结果是None
正则表达式： r'正则语法'

1.2 正则符号(正则表达式的语法)

匹配符号

1)普通字符 - 除了在正则中有特殊功能和特殊意义的符号以外的字符都算普通字符

普通字符代码字符本身

# 匹配一个字符串有三个字符，分别是'a','b','c'
re_str = r'abc'
result = fullmatch(re_str, 'abc')
print(result)

2) . - 匹配任意一个字符
一个.只能匹配一个字符

# 匹配一个字符串长度是8，前三个字符是abc,后三个字符是123，中间是两个任意字符
re_str = r'abc..123'
result = fullmatch(re_str, 'abcW1123')
print(result)

3) \w - 匹配一个数字、字母或者_ (在ASCII码表中)

一个\w只能匹配一个字符

# 匹配一个长度是4的字符串，第一个字符是数字、字母或者_，后面三个字符是'abc'
re_str = r'\wabc'
result = fullmatch(re_str, '_abc')
print(result)

4) \d - 匹配任意一个数字字符

# 匹配一个长度是5的字符串，前两个字符是任意数字，后面三个是任意字符
re_str = r'\d\d...'
result = fullmatch(re_str, '90l-=')
print(result)

5) \s - 匹配任意一个空白字符

空白字符包括: 空格字符、换行字符、制表符...

result = fullmatch(r'how\s\sare!', 'how \tare!')
print(result)

     6) \大写字母
"""
    \D - 匹配除了数字字符以外的任意字符(匹配一个非数字字符)
    \S - 匹配一个非空白字符

re_str = r'\Dabc\S'
print(fullmatch(re_str, 'pabc='))

7) [字符集] - 匹配字符集出现的任意一个字符

注意: 一个[]只能匹配一个字符
a.
[abc] - 匹配abc中任意一个字符
[赵钱孙李] - 匹配赵钱孙李中的任意一个字符
[\d\s] - 匹配任意一个数字字符或空白字符

b.
[1-9] - 匹配1到9中的任意一个字符(字符编码值递增)
[a-z] - 匹配任意一个小写字母
[A-Z] - 匹配任意一个大写字母
[a-zA-Z]  - 匹配任意一个字母
[a-zA-Z0-9_] / [A-Za-z\d_] -  匹配任意一个字母、数字或者_
[ \t\n]  - 匹配任意一个空白字符
[\u4e00-\u9fa5]  - 匹配任意一个中文字符
"""

# 匹配一个长度是4的字符串，第一个字符是1或者3或者7,后面是abc
re_str = r'[137]abc'
print(fullmatch(re_str, '7abc'))

re_str = r'[!-&]123'
print(fullmatch(re_str, '!123'))

re_str = r'[a-zA-Z0-9_]==='
print(fullmatch(re_str, 'a==='))

# print(fullmatch(r'[z-a]', 'a'))   # sre_constants.error: bad character range z-a at position 1

8) [^字符集] - 匹配不在字符集中的任意一个字符

[^abc] - 匹配任意一个不是a、b、c的字符
[^2-8] - 匹配任意一个不是2到8的字符
[^\u4e00-\u9fa5] - 匹配任意一个非中文的字符

re_str = r'[^2-8]abc'
print(fullmatch(re_str, '9abc'))

检测符号

     所有的检测符号都不会影响字符串的长度
     1)\b - 检查是否是单词边界
    单词边界 - 能够将两个单词隔开并且不会产生歧义的任意符号: 空白字符、标点符号等、字符串开头和字符串结尾
    匹配规则: 先去掉\b对字符串进行匹配，如果匹配成功再检查\b所在的位置是否是单词边界

# 匹配一个字符串长度是6，每个字符分别是abc123; 并且要求abc和123之间是单词边界
re_str = r'abc\b123'
print(fullmatch(re_str, 'abc123'))     # None

re_str = r'abc\b,123'   # abc,123
print(fullmatch(re_str, 'abc,123'))     # None

re_str = r'\b[\u4e00-\u9fa5][\u4e00-\u9fa5]\b'
print(search(r'\b\d\d\b', '画撒86旦法 67 -===双方都建行卡阿斯顿发'))

     2) ^ - 检查^所在的位置是否是字符串开头
"""
注意: 这儿的^是[]外面的
"""
re_str = r'^\d\d\d'
print(fullmatch(re_str, '345'))
print(search(re_str, '3457ajhjs789jkals728===sj234='))
print(findall(re_str, '789ajhjs789jkals728===sj234='))

     3) $  - 检查$所在的位置是否是字符串结尾
re_str = r'\d\d\d$'
print(fullmatch(re_str, '345'))
print(search(re_str, '3457ajhjs789jkals728===sj234=889'))
print(findall(re_str, '789ajhjs789jkals728===sj234=112'))

from re import *

匹配次数

控制次数的符号: 字符符号

1) * - 匹配0次或者多次 {0,}

    123a* - 123后面a出现0次或者多次, 123,123a,123aa,123aaa,123aaaa,....
    123\d* - 123后面出现0个或者多个任意数字字符, 123, 1230,12312,12384758475,...
    123[mnxy9]* - 123, 123m, 123mn, 123mmn, 123myxy9, 12399999,...

re_str = r'abc0*123'
print(fullmatch(re_str, 'abc0000123'))

2) + - 匹配1次或多次 {1,}

123a+ - 123a, 123aa, 123aaa,...

re_str = r'123[a-z]+'
print(fullmatch(re_str, '123iyujh'))

3) ? - 匹配0次或1次 {0,1}

-?123  - 123/-123

re_str = '_?abc'
print(fullmatch(re_str, '_abc'))

    4) {}
"""
    (1) {N} - 匹配N次
        a{3} - 匹配三个a, aaa
        \d{3} - 匹配三个任意数字, 345, 344, 000, 101

    (2) {M,N} - 匹配M到N次(匹配至少M次最多N次)
    (3) {M,} - 匹配至少M次, 123a{3,}: 123aaa, 123aaaa,...
    (4) {,N} - 最多N次, 123a{,3}: 123, 123a, 123aa, 123aaa

# 匹配电话号码
re_str = r'1[3-9]\d{9}'
# 匹配密码: 要求是6~12位的数字或者字母
re_str = r'[a-zA-Z\d]{6,12}'
print(fullmatch(r'123a{2,4}', '123aaa'))

贪婪和非贪婪

在匹配次数不确定的时候，会出现贪婪和非贪婪两种情况；默认情况都是贪婪。

1)什么是贪婪: 在能够匹配成功的前提下，匹配次数尽可能多

2)什么是非贪婪: 在能够匹配成功的前提下，匹配次数尽可能少; (在匹配次数后加?)

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

re_str = r'a.+'
print(search(re_str, 'hsjsa==2-32'))
print(search(r'a\d{3,5}?', '你哈a34590876'))

re_str = r'a.+b'
print(search(re_str, 'a234b123b123'))    # 'a234b123b'
re_str = r'a.+?b'
print(search(re_str, 'a234b123b123'))    # 'a234b'

# 练习: 获取data文件中name对应的值
with open('data', encoding='utf-8') as f:
    content = f.read()
    names = findall(r'"name":".+?"', content)
    print(names)

分之

1) |

正则1|正则2 - 先让正则1去匹配，如果匹配成功就成功；匹配失败再让正则2去匹配；
（正则1和正则2中只要有一个能匹配成功就行）

re_str = r'abc|123'
print(fullmatch(re_str, '123'))

re_str = r'\d{2,5}|[a-z]+123|[A-Z]'
print(fullmatch(re_str, 'H'))

分组

1) () - 将括号里面的内容作为一个整体

    2)整体操作
    r'(\d\d|[A-Z]{2})abc' - 匹配一个字符串后面是abc,前面是两个数字或者两个大写字母
    r'([a-z]\d){3}' - a8n7j8

    3)分组
    a.分组截取: 方便后面分段或者分情况取不同匹配结果
    b.分组重复: 在正则中用\X来重复前面第X个分组匹配到的内容

注意: \X的前面必须有这个分组

re_str = r'(\d{3})[a-z]{3}'
print(fullmatch(re_str, '344hsj'))
print(findall(re_str, '你还是345库函数568ksjkk-==789hsjn==hjj--890==892lsk1'))


# 234hjk234, 112kls112
re_str = r'(\d{3})([a-z]{3})\2'
print(fullmatch(re_str, '234hjshjs'))

# 练习1：写一个正则表达式匹配一个字符串: abc的前面是两个数字或者两个大写字母
# 23abc, KJabc
# 方法一:
re_str = r'\d{2}abc|[A-Z]{2}abc'
re_str = r'(\d\d|[A-Z]{2})abc'

转义符号

1) 加\

在正则中有特殊功能和特殊意义的符号前加,让这个符号的特殊功能和意义消失

re_str = r'\d{3}\.[a-z]{3}'
print(fullmatch(re_str, '234=hjs'))   # None

re_str = r'\^a\+\d{3}\\w'
print(fullmatch(re_str, '^a+344\w'))

    2) 加[]

在[]中有特殊意义的符号: a.^放在最开头 b.-放在两个字符之间
其他符号包括: .+?*$，这个单独的符号在[]中都表示这个符号本身

re_str = r'\d{3}[.][a-z]{3}'
print(fullmatch(re_str, '123=hjs'))

re_str = r'\d{3}[-a+^\]][a-z]{3}'
print(fullmatch(re_str, '123+hjs'))

from re import *

2. re模块是python提供的，专门针对正则表达式应用的相关函数

2.1 compile(正则表达式) -> 将正则表达式转换成正则对象

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

fullmatch(r'\d{3}', '347')
findall(r'\d{3}', 'asjhf238sdfjk2323')
re_obj.fullmatch('234')
re_obj.findall('asdhf2387sjfhak82334')

2.2 字符串匹配

fullmatch(正则表达式, 字符串) - 让正则表达式和字符串完全匹配
match(正则表达式,字符串) - 匹配字符串开头

以上两个方法的结果: 匹配失败结果是None,匹配成功会返回匹配对象

re_str = r'\d{3}'
print(fullmatch(re_str, '783'))    # <_sre.SRE_Match object; span=(0, 3), match='783'>
print(match(re_str, '384课时费s99fij==='))   # <_sre.SRE_Match object; span=(0, 3), match='384'>

1)匹配对象
result = match(r'(\d{3})=([a-z]{2})', '234=am按时发货就阿斯顿发')
print(result)

a.获取匹配到的字符串
"""
匹配对象.group()  -  获取整个正则表达式匹配到的字符串, 结果是字符串
匹配对象.group(N) -  获取整个正则表达式中第N个分组匹配到的字符串
"""
print(result.group())
print(result.group(1))
print(result.group(2))

b.获取匹配到的字符串在原字符串中的位置信息
"""
匹配对象.span()   -> 返回匹配结果在原字符串中的下标范围: [开始下标, 结束下标)
匹配对象.span(N)  -> 返回第N个分组匹配到的结果在原字符串中的范围
"""
print(result.span())
print(result.span(2))
start, end = result.span(1)
print(start, end)

c.获取原字符串
"""
匹配对象.string
"""
print(result.string)

2.3 查找

1) search(正则表达式,字符串) - 在字符串中查到第一个满足正则表达式的子串, 如果找到了结果是匹配对象，找不到结果是None

2) findall(正则表达式，字符串) - 获取字符串中所有满足正则表达式的子串；返回值是一个列表
注意: 如果正则表达式中有分组，列表中的匹配结果只会去分组匹配到的内容

3) finditer(正则表达式,字符串) - 获取字符串中所有满足正则表达式的子串；返回值是一个迭代器，元素是匹配对象

result = search(r'\d{3}', '是否234ash==347jshdf')
print(result)

result = findall(r'\d{3}[a-z]{2}', '是234hu士大夫345mmks89h-=数348kl几十块的')
print(result)   # ['234hu', '345mm', '348kl']

result = findall(r'(\d{3})[a-z]{2}', '是234hu士大夫345mmks89h-=数348kl几十块的')
print(result)   # ['234', '345', '348']

result = findall(r'(\d{3})([a-z]{2})', '是234hu士大夫345mmks89h-=数348kl几十块的')
print(result)    # [('234', 'hu'), ('345', 'mm'), ('348', 'kl')]

result = findall(r'(([A-Z]{2}|\+)\d{2})', 'SH34士大夫+34阿客户方LL345==')
print(result)    # [('SH34', 'SH'), ('+34', '+'), ('LL34', 'LL')]


result = finditer(r'(\d{3})([a-z]{2})', '是234hu士大夫345mmks89h-=数348kl几十块的')
group = []
group1 = []
group2 = []
for x in result:
    group.append(x.group())
    group1.append(x.group(1))
    group2.append(x.group(2))

print(group)
print(group1)
print(group2)

2.4 切割

split(正则表达式, 字符串) - 将字符串中满足正则表达式的子串作为切割点对字符串进行切割; 返回一个字符串列表

result = split(r'\d+', '爱好3ja89是电话费899将括号看0===三等奖9数据98=的')
print(result)

2.5 替换

sub(正则表达式,字符串1,字符串2) - 将字符串2中所有满足正则表达式的子串都替换成字符串1;返回一个字符串

message = '你丫是傻叉吗? 我操你大爷的. Fuck you.'
new_message = sub(r'[操肏艹草曹]|fuck|shit|傻[比屄逼叉缺吊屌]|煞笔', '*', message, flags=IGNORECASE)
print(new_message)

Day17 - 总结