正则表达式

正则表达式

1.定义：进行数据筛选的表达式

2.原子

原子是正则表达式中最基本的组成单位，每个正则表达式至少要包含一个原子。常见的原子类型有：

1. 普通字符
2. 非打印字符
3. 通用字符
4. 原子表

import  re
#1.普通字符作为原子
string="xiaokaimin"
pat="min"
resoult=re.search(pat,string)
print(resoult)
print("========================================")

#2.非打印字符作为原子
#非打印字符     \n 换行符     \t制表符
string='''xiaokaimin
               baidu'''
pat="\n"
resoult=re.search(pat,string)
print(resoult)

#3.通用字符作为原子
'''
\w    匹配任意字母数字或者下划线
\W   匹配除字母数字或者下划线
\d   匹配十进制数
\D  匹配除了十进制数的其他
\s  匹配空白字符
\S  匹配除空白字符的其他
'''
string='''xiaokaimin8888baidualitenxun'''
pat="\d\d\d"
a="\w\w\w\w\d"
resoult=re.search(pat,string)
resoult2=re.search(a,string)
print(resoult)
print(resoult2)

print("------------------------------------------------------")

#4.原子表作为原子
string="xiaokaimin"
pat="mi[mon]"
pat1="mi[^mon]"
pat2="xi[moa]o"
pat3="xi[^moa]o"
resoult=re.search(pat,string)
resoult1=re.search(pat1,string)
resoult2=re.search(pat2,string)
resoult3=re.search(pat3,string)
print(resoult)
print(resoult1)
print(resoult2)
print(resoult3)
    
    
 输出结果：
<re.Match object; span=(7, 10), match='min'>
========================================
<re.Match object; span=(10, 11), match='\n'>
<re.Match object; span=(10, 13), match='888'>
<re.Match object; span=(6, 11), match='imin8'>
------------------------------------------------------
<re.Match object; span=(7, 10), match='min'>
None
<re.Match object; span=(0, 4), match='xiao'>
None

Process finished with exit code 0

3.元字符

就是正则表达式中具有一些特殊含义的字符，比如重复N次前面的字符

#元字符
'''
.  除换行符外任意一个字符
^ 匹配开始位置
$ 匹配结束位置
*  前面的原子重复出现一次零次或者多次
？ 前面的原子重复出现一次零次
+ 前面的原子重复出现一次多次
{n}  前面的原子恰好出现n次
{n，}  前面的原子至少出现n次
{n，m}  前面的原子至少出现n次，至多出现m次
|  模式选择符或
() 模式单元
'''
import  re
string="xiaokaimin8888tenxunalibaidu"
pat="^xiao......"
pat1="baidu$"
pat2="min8{4}"
resoult4=re.search(pat,string)
resoult5=re.search(pat1,string)
resoult6=re.search(pat2,string)
print(resoult4)
print(resoult5)
print(resoult6)
    
    
输出结果：
<re.Match object; span=(0, 10), match='xiaokaimin'>
<re.Match object; span=(23, 28), match='baidu'>
<re.Match object; span=(7, 14), match='min8888'>

4.模式修正符

可以在不改变正则表达式的情况下通过模式修正符改变正则表达式的含义，从而实现一些匹配的结果与功能。

#模式修正符
# I  匹配时候忽略大小写
# M  多行匹配
# S 让.匹配包括换行
# U unicode
# L 本地化识别匹配
import  re
string="python"
pat4="Pyt"
pat5="pyt"
pat6="Pyt"
resoult7=re.search(pat4,string)
resoult8=re.search(pat5,string)
resoult9=re.search(pat6,string,re.I)
print(resoult7)
print(resoult8)
print(resoult9)


输出结果：
None
<re.Match object; span=(0, 3), match='pyt'>
<re.Match object; span=(0, 3), match='pyt'>

5.贪婪模式和懒惰模式

贪婪模式：尽可能的多匹配

懒惰模式：尽可能的少匹配

#贪婪模式和懒惰模式
import  re
string="pythony"
pat7="p.*y"      #    .*      贪婪模式
pat8="p.*?y"    #    .*?    懒惰模式，精准
resoult10=re.search(pat7,string,re.I)
resoult11=re.search(pat8,string,re.I)
print(resoult10)
print(resoult11)



输出结果：
<re.Match object; span=(0, 7), match='pythony'>
<re.Match object; span=(0, 2), match='py'>

6.正则表达式函数

正则表达式函数有re.match()函数，re.search()函数，全局匹配函数，re.sub()函数。

#正则表达式函数
# 1.match
#     从头开始匹配
import  re
string="poython"
pat9="p.*?t"
pat10="o.*?t"
resoult12=re.match(pat9,string)
resoult13=re.match(pat10,string)
print(resoult12)
print(resoult13)

# 2.search
#     从任意地方匹配,前面讲过


# 3.全局匹配函数
#格式：re.compile(正则表达式).findall(数据)
string="poythonpoythonpzay"
pat11="p.*?y"
resoult14=re.compile(pat11).findall(string)
print(resoult14)



输出结果：
<re.Match object; span=(0, 4), match='poyt'>
None
['poy', 'poy', 'pzay']

7.实例

#如何匹配.com/.cn网址/电话号码
#1.匹配.com/.cn
import re
string="<a href='Http://www.baidu.com'>百度首页</a>'"
pat="[a-zA-Z]+://[^\s]*[.com|.cn]"
resoult=re.compile(pat).findall(string)
print(resoult)

#2.匹配电话号码
string="ahuahuah021-12121212zhu0000-1234564zbyb"
pat1="\d{4}-\d{7}|\d{3}-\d{8}"
resoult=re.compile(pat1).findall(string)
print(resoult)



输出结果：
['Http://www.baidu.com']
['021-12121212', '0000-1234564']