1.什么是正则表达式

正则表达式是字符串匹配工具，是为了在某些需求下可以更方便、更快捷的处理字符串

2.怎么使用正则处理字符串

python通过提供re模块来支持正则表达式

re.fullmatch(正则表达式，字符串) - 让正则表达式和字符串进行完全匹配，返回匹配结果，如果匹配不成功返回None

3.怎么写正规表达式

python中正则表达式是放在字符串中，并且这个字符串一般会在最前面加r/R。

r'正则'

4.正则语法

普通字符 - 代表字符本身

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

. - 匹配任意一个字符
一个 . 代表一个字符，匹配是任意字符

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

\w - 匹配一个ASCII表中的字母，数字，下划线。还可以匹配非ASCII码表字符

re_str = r'.\w'
result = re.fullmatch(re_str,'s_')
print(result)

\s - 匹配一个空白字符

空白字符包括：空格，回车，制表符

re_str = r'\s\sa'
result = re.fullmatch(re_str,'\n\ta')
print(result)

\d - 匹配一个数字字符

re_str = r'年龄:\d\d'
result = re.fullmatch(re_str,'年龄:12')
print(result)

\b - 检测单词边界(检测\b所在的位置是否是单词边界)

单词边界：所有能够标志一个单词开始或者结束的符号。

^ - 检测是否是字符串开头

result = re.fullmatch(r'^\d\d','23')
print(result)

$ - 检测是否是字符串结尾

result = re.fullmatch(r'\d\d$','89金额：23,100 年龄：81')
print(result)

\大写字母 - 对‘\小写字母’的否定

\W  -  匹配非数字、字母、下划线
\S  -  匹配非空白字符
\D  -  匹配非数字字符
\B  -  检测是否是非单词边界

[字符集] - 匹配 [] 中任意一个字符

a.
[普通字符集] - 匹配 [] 中任意一个字符

b.用 - 表示范围
[字符1-字符2] - 匹配编码值在字符1编码到字符2编码之间的任意一个字符  （ord(字符1) < ord(字符 2)）
[0-9]  -  所有数字字符中的一个
[2-9]  -  所有'2'-'9'数字字符中的一个
[一-龥] - 所有中文字符中的一个

c.[]内容中的最前面加^,表示否定 （只有放在[]里的最前面才有意义）
[^abc]   -  表示 除了'a''b''c'的任意一个字符
[^a-z]   -   表示 除了小写字母的任意一个字符

# 匹配一个字符串长度为 4 ，后3位是‘123’，第一位是 ‘a’‘b’‘c’中任意一个
re_str = r'[abc]123'
result = re.fullmatch(re_str,'a123')
print(result)

转义符号 - 将正则中有特殊意义或者特殊功能的符号 变成普通符号

a.在中括号外
在特殊符号前加'\'让其特殊意义消失

b.在中括号内
单独的有特殊意义的符号，除了'^'在最前面，'-'在两个字符之间，其他的都不需要转义，特殊意义自动消失

================匹配次数==============

• • 匹配 0 次 或者 多次

r'a*bc' -  匹配一次字符串，'bc'前有0个或者多个a
r'\d*'  -   匹配一个字符串由 0 个或者多个任意数字字符组成

"""

re_str = r'a\d*b'
result = re.fullmatch(re_str,'a12b')
print(result)

# 练习，写一个正则表达式能够匹配所有的小数
re_str = r'\d\d*\.\d\d*'
result = re.fullmatch(re_str,'5144.1233')
print(result

• • 匹配至少一次

re_str = r'\d+\.\d+'
result = re.fullmatch(re_str,'5144.1233')
print(result)

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

re_str = r'\d{4}'
result = re.fullmatch(re_str,'2134')
print(result)

re_str = r'\d{2,5}'
result = re.fullmatch(re_str,'12')
print(result)

re_str = r'\d{4,}'
result = re.fullmatch(re_str,'2134')
print(result)

re_str = r'\d{,4}'
result = re.fullmatch(re_str,'')
print(result)

? - 匹配 0 次或 1 次

==============贪婪和非贪婪==============

匹配次数不明确时，尽可能多的匹配 为 贪婪匹配

非贪婪匹配 是在 次数不明确的符号后面加 ？

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

===================分支/选择=============

正则1 | 正则2 - 先用正则1去匹配，如果匹配成功就成功，匹配不成功再使用正则2去匹配

 要求用户名全部都是数字或者字母，长度是6-12
re_str = r'\d{6,12}|[a-zA-Z]{6,12}'
result = re.fullmatch(re_str,'caqwqdqqfq')
print(result)

=================分组()==================
"""
a.将小括号中的内容当做一个整体来操作

b. \数字 - 重复第几个分组匹配结果
"""

re_str = r'[a-zA-Z\d](a|b|c)'
result = re.fullmatch(re_str,'2c')
print(result)

re_str = r'(a|b|c)(a|b|c)\2(a|b|c)'
result = re.fullmatch(re_str,'abbb')
print(result)

完全匹配 - 让字符串长度，字符的值和正则表达式完全匹配
"""
re.fullmatch(正则表达式，字符串) - 匹配成功返回匹配对象，匹配失败返回None

当需要对整个字符串进行条件判断的时候使用：
"""

result = re.fullmatch(r'(\d{3})=([a-z]{3})','234=haj')
print(result)   #<_sre.SRE_Match object; span=(0, 7), match='234=haj'>

span 匹配到的内容在源字符串中的位置

print(result.span())  # (0, 7)
print(result.span(1))  # (0, 3)    正则表达式中第一个分组匹配结果的范围
print(result.span(2))  # (4, 7)    正则表达式中第二个分组匹配结果的范围

print(result.start(2),result.end(2))  # 4 7

获取匹配到的值

print(result.group())    # 整个正则表达式的匹配结果
print(result.group(1))   #  第一个分组的匹配结果
print(result.group(2))   #  第二个分组的匹配结果

获取原字符串`

print(result.string)

匹配字符串开头
"""
re.match(正则表达式，字符串) - 判断字符串的开头是否和正则表达式相匹配，匹配成功返回匹配对象，失败返回None

只检测字符串开头是否满足要求
"""

result = re.match(r'\d{3}','123aaaaa')
print(result)

search

"""
re.search(正则表达式，字符串) - 在字符串中查找是否有和正则表达式匹配的字串，如果没有返回None
如果有就返回第一个匹配结果
"""

result = re.search(r'(\d{3})=([a-z]{3})','how 231=aasdd3232=12121===')
print(result,result.span(),result.group())

findall

"""
re.findall(正则表达式，字符串) - 获取字符串中所有满足正则表达式的字串，以列表的形式返回

注意: 正则表达式中含有分组，如果只有一个分组，列表元素就是分组匹配到的内容
如果有多个分组，列表的元素 就是每个分组匹配的结果以元祖形式呈现
"""

result = re.findall(r'\d+','au asdai2nbiu23b3ibi 8abaib9')
print(result)

finditer

"""
re.finditer(正则表达式，字符串) - 获取字符串中所有能够和正则表达式匹配的子串的匹配结果。
返回值是一个迭代器，迭代器中的元素是匹配结果
"""

result = re.finditer(r'abc(\d|[A-Z]{2})','abc2-abcHD===')
print(result)

for item in result:
    print(item.group(),item.span())
    print(item.group(1))


result = re.findall(r'\d+\.\d+|\d+','are 89he ks90.2 ans78oo1.23h!w9end9009ooo')
print(result)          # r'\d+\.?\d*'
sum = 0
for item in result:
    sum += float(item)
print(sum)

split

"""
re.split(正则表达式，字符串) - 将字符串按照满足正则表达式的子串进行切割
"""

result = re.split(r'[=/-]','aaa=ddd-aaw/w22')
print(result)

sub

"""
re.sub(正则表达式，新字符串，字符串,替换次数) - 将字符串中满足正则表达式的子串替换成新字符串

替换次数可以不复制，表示全部替换
"""

result = re.sub(r'\d','=','aoh2iho23oh441nb23h1h3')
print(result)