4.正则表达式

正则表达式是一个特殊的字符序列，它能帮助你方便的检查一个字符串是否与某种模式匹配。

• 原子
  原子是正则表达式的最基本的组成单位，而且在每个模式中最少包含一个原子。原子是由所有那些未显示指定为元字符的打印和非打印字符组成。

1.普通字符作为原子
普通字符是编写正则表达式时最常见的原子了，包括所有的大写和小写字母字符、所有数字等。例如，a——z、A——Z、0——9。

import re
pattern = 'pp'
String = "pptoroyd"
#re.search()函数对整个字符串搜索，并返回第一个匹配字符串的match对象
Result = re.search(pattern,String)

print(f"普通字符作为原子的结果:{Result}")
# 普通字符作为原子的结果:<re.Match object; span=(0, 2), match='pp'>

2.一些特殊字符和元字符作为原子
任何一个符号都可以作为原子使用，但如果这个符号在正则表达式中有一些特殊意义，我们就必须使用转义字符“\”取消它的特殊意义，将其变成一个普通的原子。例如，所有标点符号以及一些其他符号，双引号''''、单引号''、“*”、“+”、“.”等，如果当原子就必须像\”、\’、+和.这样使用。

import re
#需要转义
pattern = '\+'
String = "a+b=c"
#re.search()函数对整个字符串搜索，并返回第一个匹配字符串的match对象
Result = re.search(pattern,String)

print(f"特殊字符作为原子的结果:{Result}")
# 特殊字符作为原子的结果:<re.Match object; span=(1, 2), match='+'>

3.一些非打印字符作为原子
所谓的非打印字符，是一些在字符串中的格式控制符号，例如:\n回车及\t制表符号等。例如下表所示列出了正则表达式中常用的非打印字符及其含义。

import re
pattern = '\n'
String = """tyhjhgtrsdfg
sn"""
#re.search()函数对整个字符串搜索，并返回第一个匹配字符串的match对象
Result = re.search(pattern,String)

print(f"非打印字符作为原子的结果:{Result}")
# 非打印字符作为原子的结果:<re.Match object; span=(12, 13), match='\n'>

4.使用“通用字符类型”作为原子
前面介绍的不管是打印字符还是非打印字符作为原子，都是一个原子只能匹配一个字符。而有时我们需要一个原子可以匹配一类字符，例如，匹配所有数字不是一个数字，匹配所有字母而不是一个字母，这时就要使用“通用字符类型”了。

字母	意义
/w	匹配任意一个字母、数字或者下划线
/W	匹配除字母、数字和下划线意外的任意一个字符
/d	匹配仍以一个十进制数
/D	匹配除十进制数意外的任意一个其他字符
/S	匹配除空白字符意外的任意一个其他字符
/s	匹配任意一个空白字符

import re
pattern ='\who\w'
String = "wo shi who23"
#re.search()函数对整个字符串搜索，并返回第一个匹配字符串的match对象
Result = re.search(pattern,String)

print(f"通配符作为原子的结果:{Result}")
# 通配符作为原子的结果:<re.Match object; span=(7, 11), match='who2'>

5.原子表
代表某一类的原子太多了，系统不能全都给提供出来，例如数字中的奇数（1、3、5、7、9、）、字母中的元音字母（a、e、i、o、u）等。所以就需要我们可以自己定义出特定的“类原子”，使用原子表“[]”就可以定义一组彼此地位平等的原子，且从原子表中仅选择一个原子进行匹配。
在Python中，原子表由[]表示，比如[xyz],就是一个原子表，这个原子表中定义了3个原子，这3个原子的地位平等。

import re
pattern1 ='\wf[gj]\w'
pattern2 ='\wf[^gj]\w'
pattern3 ='\wf[gj]\W'

String = "abcdefgjikdlfk"
#re.search()函数对整个字符串搜索，并返回第一个匹配字符串的match对象
Result1 = re.search(pattern1,String)
Result2 = re.search(pattern2,String)
Result3 = re.search(pattern3,String)
print(f"pattern1:{Result1}")
print(f"pattern2:{Result2}")
print(f"pattern3:{Result3}")
# pattern1:<re.Match object; span=(4, 8), match='efgj'>
# pattern2:None
# pattern3:None

• 元字符

符号	说明
.	表示任意字符
^	表示字符开头
$	表示字符串结尾
*, +, ?	'*'表示匹配前一个字符重复 0 次到无限次，'+'表示匹配前一个字符重复 1次到无限次，'?'表示匹配前一个字符重复 0 次到1次
{m}	匹配前一个字符 m 次
{m,n}	匹配前一个字符 m 到 n 次
{m,n}?	匹配前一个字符 m 到 n 次，并且取尽可能少的情况

1.任意匹配元字符

import re
String = "abcdefgjikdlfk"
pattern = 'a.c'
Result = re.search(pattern,String)
print(f"结果：{Result}")
# 结果：<re.Match object; span=(0, 3), match='abc'>

2.边界限制元字符
边界限制符，’^’匹配字符串的开始，使用’$’匹配字符串的结束

import re
String = 'Hello'
pattern1 = '^H'
pattern2 = 'o$'
Result1 = re.search(pattern1, String)
Result2 = re.search(pattern2, String)
print(f"结果1：{Result1}")
print(f"结果2：{Result2}")
# 结果1：<re.Match object; span=(0, 1), match='H'>
# 结果2：<re.Match object; span=(4, 5), match='o'>

3.限定符
常见的限定符包括*、?、+、{n}、{n,}、{n,m}

import re
String = 'mnjsassssh'
pattern1 = 'as{2}'
pattern2 = 'as{3}'
pattern3 = 'as{2,}'
Result1 = re.search(pattern1, String)
Result2 = re.search(pattern2, String)
Result3 = re.search(pattern3, String)
print(f"结果1：{Result1}")
print(f"结果2：{Result2}")
print(f"结果3：{Result3}")
# 结果1：<re.Match object; span=(4, 7), match='ass'>
# 结果2：<re.Match object; span=(4, 8), match='asss'>
# 结果3：<re.Match object; span=(4, 9), match='assss'>

4.模式选择符
模式选择符’|’
使用模式选择符，可以设置多个模式，匹配时，可以从中选择任意一个模式匹配。

import re
String = 'mnjsaokssh'
pattern = 'mn|ji'
Result = re.search(pattern, String)
print(f"结果1：{Result}")
# 结果1：<re.Match object; span=(0, 2), match='mn'>

5.模式单元
模式单元符()，可以使用’()’将一些原子组合成一个大原子使用，小括号括起来的部分会被当做一个整体去使用

import re

String = 'mnjsassssh'
pattern1 = '(ss){1,}'#ss至少出现一次
pattern2 = '(ss){1}' #ss出现一次
pattern3 = '(as){1,}'#a字母后的s至少出现一次
pattern4 = '(as){1}'#a字母后的s出现一次
Result1 = re.search(pattern1, String)
Result2 = re.search(pattern2, String)
Result3 = re.search(pattern3, String)
Result4 = re.search(pattern4, String)
print(f"结果1：{Result1}")
print(f"结果2：{Result2}")
print(f"结果3：{Result3}")
print(f"结果4：{Result4}")
# 结果1：<re.Match object; span=(5, 9), match='ssss'>
# 结果2：<re.Match object; span=(5, 7), match='ss'>
# 结果3：<re.Match object; span=(4, 6), match='as'>
# 结果4：<re.Match object; span=(4, 6), match='as'>

• 模式修正符

符号	含义
I	匹配时忽略大小写
M	多行匹配
L	做本地化识别匹配
U	根据Unicode字符及解析字符
S	让.匹配包括换行符，即用了该模式修正后，”.”匹配就可以匹配任意的字符了

忽略大小写

import re
pattern1 = "python"
pattern2 = "python"
string = "abcdfphp345Pythony_py"
result1 = re.search(pattern1, string)
result2 = re.search(pattern2, string, re.I)
print(f"结果1:{result1}")
print(f"结果2:{result2}")
# 结果1:None
# 结果2:<re.Match object; span=(11, 17), match='Python'>

• 贪婪模式与懒惰模式

import re
pattern1 = "p.*y"  # 贪婪模式
pattern2 = "p.*?y"  # 懒惰模式
string = "abcdfphp345pythony_py"
result1 = re.search(pattern1, string)
result2 = re.search(pattern2, string, re.I)
print(f"贪婪模式结果:{result1}")
print(f"懒惰模式结果:{result2}")
# 贪婪模式结果:<re.Match object; span=(5, 21), match='php345pythony_py'>
# 懒惰模式结果:<re.Match object; span=(5, 13), match='php345py'>

• 常用函数
  1.search
  re.search---re.search扫描整个字符串并返回第一个成功的匹配
  2.match
  re.match---从字符串的起始位置匹配一个模式，如果不是起始位置匹配成功的话，match()就返回none

import re
string = "ipythonajsoasaoso"
pattern = "ipython."
result = re.match(pattern, string)
result1 = re.match(pattern, string).span()
print(f"结果1:{result}")
print(result1)

# 结果1:<re.Match object; span=(0, 8), match='ipythona'>
# (0, 8)

import re
string = "ipythonajsoasaoso"
pattern = "python"
result = re.match(pattern, string)
print(f"结果:{result}")
# 结果:None

3.全局匹配函数
将符合模式的全部内容都匹配出来
（1）使用re.compile()对正则表达式进行预编译
（2）编译后使用findall()根据正则表达式从原字符串中将匹配的解决全部找出

import re
string = "helloipythonajsoasaospythono"
result = re.compile(".python.").findall(string) #找出符合模式的所有结果
print(f"结果:{result}")
# 结果:['ipythona', 'spythono']

4.re.sub()函数
根据正则表达式来实现替换某些字符串
re.sub(pattern, rep, string, max)
第一个参数对应的正则表达式，第二个参数为要替换成的字符串，第三个参数为源字符串，第四个参数为可选项，代表最多替换的次数，如果忽略不写，则会将符合模式的结果全部替换。

import re
string = "bnsdBBjsdkBBlsBBdkBBs"
pattern = "BB"
result1 = re.sub(pattern,"**",string)  #全部替换
result2 = re.sub(pattern,"**",string,1)  #最多替换1次
result3 = re.sub(pattern,"**",string,2)  #最多替换2次
print(f"结果1:{result1}")
print(f"结果2:{result2}")
print(f"结果3:{result3}")
# 结果1:bnsd**jsdk**ls**dk**s
# 结果2:bnsd**jsdkBBlsBBdkBBs
# 结果3:bnsd**jsdk**lsBBdkBBs