regular1

1. 什么是正则表达式
   正则表达式是字符串匹配工具，它是为了在某些需求下可以更方便快速的处理字符串

2. 怎么使用正则处理字符串
   python通过提供re模块来支持正则表达式
   re.fullmatch(正则表达式，字符串) - 让正则表达式和字符串进行完全匹配，返回匹配结果，如果匹配不成功返回None

3. 怎么写正则表达式
   Python中正则表达式是放在字符串中的，并且这个字符串一般会在最前面加r/R
   r'正则'

4. 正则语法

# 1）普通字符  -  代表字符本身
import re
re_str = r'abc'
result = re.fullmatch(re_str, 'abc')
print(result)

# 2).  -  匹配一个任意字符
"""
一个.代表一个字符，匹配的是任意字符
"""
# 匹配一个字符串，长度是4，第一个字符是任意字符，后面三位是‘abc’
re_str = r'.abc'
result = re.fullmatch(re_str, '+abc')
print(result)

# 3)\w  -  匹配一个ASCII表中字母，数字或者下划线，还可以匹配所有的非ASCII表字符
re_str = r'.\w'
result = re.fullmatch(re_str, '=猪')
print(result)

# 4）\s  -  匹配一个空白字符
"""
空白字符包括：空格，回车，制表符
"""
# 匹配一个字符串有四个字符，第一个字符是空白，后面三个任意字符
re_str = r'\s...'
result = re.fullmatch(re_str, '\nyou')
print(result)

# 5）\d  -  匹配一个数字字符
# 匹配一个字符串长度是5，前面三个字符是‘年龄：’，后面是两个任意数字
re_str = r'年龄：\d\d'
result = re.fullmatch(re_str, '年龄：12')
print(result)

# 6）\b  -  检测单词边界（检测\b所在的位置是否是单词边界）
"""
单词边界：所有能够标志一个单词结束的符号都是单词边界，例如：空格，换行，标点符号等，字符串开头，字符串结束
how are you? i am fine, thank you!
"""
# 匹配一个字符串是否是‘how,are’，并且要求w后面是一个单词边界
re_str = r'\bhow\b,are\b'
result = re.fullmatch(re_str, 'how,are')
print(result)

re_str = r'\byou\b'
result = re.search(re_str, 'hoyouw areyou you!')
print(result)

# 7）^  -  检测是否是字符串开头
# 匹配两个数字字符的字符串，并且检测这个字符串是否是字符串开头
re_str = r'^\d\d'
result = re.fullmatch(re_str, '23')
print(result)

# 8）$  -  检测是否是字符串结尾
result = re.findall(r'\d\d$', '89金额：23,100 年龄：81')
print(result)

# 9)\大写字母  -  对'\小写字母'功能的否定
"""
\W  -  匹配非数字、字母、下划线
\S  -  匹配非空白字符
\D  -  匹配非数字字符
\B  -  检测是否是非单词边界
"""
re_str = '\W\S\D'
result = re.fullmatch(re_str, '/nl')
print(result)

# 10) [字符集]  -  匹配[]中任意的一个字符
"""
a.取出字符集中的一个
[普通字符集]  -  匹配[]中任意的一个字符
[abc]、[ab\d]、[123]

b.用-表示范围
[字符1-字符2]  -  匹配编码值在字符1编码到字符2编码之间的任意一个字符（ord(字符1)<ord(字符2)）
[0-9]  -  所有数字字符中的一个，相当于\d
[2-9]  -  数字字符'2'到'9'中的一个
[一-龥]  -  所有中文字符中的一个
[a-zA-Z]  -  所有的字母字符
[a-zA-Z\d_]  -  字母数字下划线

c.[]内容中的最前面加^,表示否定（^只有放在[]里面的最前面才有意义，在[]其他位置就是表示普通字符'^'）
[^abc]  -  匹配除了'a','b','c'以外的任意一个字符
[^a-z]  -  匹配除了小写字母以外的任意一个字符
"""
# 匹配一个字符串长度是4，后三位是'123'，第一位是'a','b','c'中的任意一个
re_str = r'[abc]123'
result = re.fullmatch(re_str, 'b123')
print(result)

# 第一个字符是'a' 'b' 或者任意一个数字字符
re_str = r'[ab\d]123'
result = re.fullmatch(re_str, '8123')
print(result)

re_str = r'[1-4]123'
result = re.fullmatch(re_str, '3123')
print(result)
print(chr(0x9fa5))

# 第一个字符是'a','z','-'
re_str = r'[az-]123'
result = re.fullmatch(re_str, '-123')
print(result)

# 匹配第一个字符不是字母
re_str = r'[^a-z]123'
result = re.fullmatch(re_str, 'h123')
print(result)

# 11）转义符号  -  将正则中有特殊意义或特殊功能的符号，表示符号本身（让特殊意义和功能消失）
"""
a.在中括号外面
在特殊意义的符号前加'\'让其特殊意义消失

b.在中括号里面
单独的有特殊意义的符号，除了'^'在最前面，'-'在两个字符之间，其他的都不需要转义，特殊意义自动消失
"""
# 12.45, 33.89
re_str = r'abc\\d'
result = re.fullmatch(re_str, 'abc\d')
print(result)

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

# 写一个正则，匹配金额，金额要求小数点后面保存两位小数
# 1.22, 100.33, 34.13, 1009.46......
r'[1-9]\d\d\.\d\d'

regular2

1. =======匹配次数========

# 1）*  -  匹配0次或多次
"""
r'a*bc'  -  匹配一个字符串，'bc'前面有0个或多个'a'，例如：'bc', 'aaabc', 'abc'...
r'\d'  -  匹配一个字符串由0个或多个任意数字字符组成，例如：'','1','234'...
r'[abc\d]*-'  -  '-', 'aac34-'...
"""
import re
re_str = r'a\d*b'
result = re.fullmatch(re_str, 'a123b')
print(result)


re_str = r'\d\d*\.\d\d*'
result = re.fullmatch(re_str, '0.34')
print(result)

# 2)+  -  匹配一次或多次（至少一次）
"""
r'\d+'  -  数字出现一次或多次
r'[zbc]+'  -  匹配一个字符串有一个或多个字符，每一个字符是abc中的一个
r'a+|b+|c+'  -  匹配一个字符串全是a或b或c
"""
re_str = r'a+bc'
result = re.fullmatch(re_str, 'abc')
print(result)

# 3）{}
"""
{N}  -  匹配N次，{3} - 匹配三次
{M, N}  -  匹配M到N次
{M,}  -  匹配至少M次
{,N}  -  匹配至多N次
"""
re_str = r'\d{3}'
result = re.fullmatch(re_str, '123')
print(result)

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

re_str = r'[a-zA-Z][a-zA-Z\d]{5,11}'
result = re.fullmatch(re_str, 'Ssafj80')
print(result)

re_str = r'a{3,}'
result = re.fullmatch(re_str, 'aaaaa')
print(result)

re_str = r'a{,3}'
result = re.fullmatch(re_str, 'aaa')
print(result)

# 4) ?  -  匹配0次或一次

2. ======贪婪和非贪婪======

4）贪婪和非贪婪

# 以上是贪婪匹配：匹配次数不确定的时候，尽可能多的匹配
# 非贪婪：
"""
在匹配次数不确定的符号后加？  -  尽可能少的匹配
*?
+?
{M,N}?
{M,}?
{,N}?
"""
re_str = r'a{3,}'
result = re.search(re_str, 'aaaaaaaaa')
print(result)

re_str = r'a{3,}?'
result = re.search(re_str, 'aaaaaaaaa')
print(result)

3. ========分支/选择=========
   正则1|正则2 - 先用正则1区匹配，如果匹配成功就成功，匹配不成功再使用正则2去匹配
   （字符串能够和正则1和正则2中的任意一个匹配成功就成功）

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

4. ========分组=========
   a.将小括号中的内容作为一个整体操作
   b.\数字 - 重复第几个分组匹配结果

# 用户名是7-13位，最后两位必须是aa或bb或cc
re_str = r'[a-zA-Z\d]{5,11}(aa|bb|cc)'
result = re.fullmatch(re_str, 'af89077bb')
print(result)

re_str = r'(\d{3})([a-z]{3})-\2\1\1'
result = re.fullmatch(re_str, '123abc-abc123123')
print(result)

reModule

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

当需要对整个字符串进行条件判断的时候使用，例如检查账号是否合法，密码是否正确等

import re
result = re.fullmatch(r'(\d{3})=([a-z]{3})', '234=hak')
print(result)
# 1)匹配到的内容在原字符串中的位置
print(result.span())  # 整个正则表达式匹配结果的范围
print(result.span(1))  #正则表达式中第一个分组匹配结果的范围
print(result.span(2))  #正则表达式中第二个分组匹配结果的范围

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

# 3）获取原字符串
print(result.string)

2. 匹配字符串开头

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

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

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

3. search

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

result = re.search(r'(\d{3})=([a-z]{3})', 'how 238=abcde8790=abc===')
print(result, result.span(1), result.group(1))

4. findall
   re.findall(正则表达式， 字符串) - 获取字符串中所有满足正则表达式的子串，以列表的形式返回
   注意：正则表达式中有没有分组
   没有分组 - 整个正则表达式匹配的结果作为列表元素（列表元素是字符串）
   有一个分组 - 这个分组匹配到的结果作为列表元素（列表元素是字符串）
   多个分组 - 将元祖作为列表元素，每个分组匹配到的结果作为元祖的元素（列表元素是元祖）

result = re.findall(r'(\d+)([a-z])', 'are 89he ks902 and89ouiu! 9sd9009oo')
print(result)

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

result = re.finditer(r'abc(\d|[A-Z]{2})', 'abc4-abcHD===')
print(result)
for item in result:
    print(item.group(), item.span())
    print(item.group(1))

# re 89he ks90.2 ans78oo1.23h!w9end9009ooo 求其中所有数字的和
nums = re.findall(r'\d+\.?\d*', 're 89he ks90.2 ans78oo1.23h!w9end9009ooo')
print(nums)
sum1 = 0
for num in nums:
    sum1 += float(num)
print(sum1)


nums = re.findall(r'\d+\.\d+|\d+', 're 89he ks90.2 ans78oo1.23h!w9end9009ooo')
print(nums)

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

result = re.split(r'[=/-]', 'aaa=jjj-lll/sss')
print(result)

7. sub
   re.sub(正则表达式， 新字符串， 字符串， 替换次数) - 将字符串中满足正则表达式的子串替换成新字符串
   替换次数不赋值，表示全部替换

result = re.sub(r'\d+', '=', 'asdf98asd0sa88asa78aaa8', 2)
print(result)