我的Python之路：正则表达式和cooking的使用

有的时候我们在进行字符串处理的时候希望按自定义规则进行处理，我们将这些规则称为模式。我们一般用正则表达式进行描述。

1.什么是正则表达式

简单来说，正则表达式就是描述字符串排列的一套规则。

比如：我们一个网页中的所以电子邮件，其他的信息都要过滤掉，那么此时我们可以观察电子邮件的格式，写一个正则表达式来表示所有的电子邮件，

随后我们可以按照正则表达式从网页中提取出所有满足该规则的电子邮件。

2.正则表达式的基础知识

2.1原子

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

（1）普通字符作为原子

（2）非打印字符作为原子

（3）通用字符作为原子

（4）原子表

2.1普通字符作为原子

在这我们可以使用数字、大小写字母、下划线都可以作为原子使用

如：

#!/uer/bin/env python
#-*-coding: utf-8 -*-
import re
pat="yuea"###非普通字符作为原子
string="http:yem.iqianyuea.com"
result=re.search(pat,string)######在string中寻找pat，并且进行匹配
print(result)

C:\Python36\pythonw.exe D:/python3练习代码/正则表达式.py
<_sre.SRE_Match object; span=(14, 18), match='yuea'>
4
<class '_sre.SRE_Match'>

Process finished with exit code 0

注意在一下例子中如果需要模块，我们将不会在次调用

在上述例子中我们需要使用正则表达式，所以我们导入了re模块。导入模块后，我们在进行设置正则表达式，并且将

表达式内容赋值给pat，然后在定义字符串，再用re模块中的search从字符串中匹配pat.如果匹配成功就打印出来，没有就为空

2.2非打印字符作为原子

所谓的非打印字符，指的是一下在字符串中用于格式化的符号，比如换行符“\n“用于匹配一个换行符、”\t“用于匹配一个制表符，比如，可以

输入以下程序来实现换行符的匹配：

paty="\n"
string='''https://i.cnblogs.com/EditPosts.aspx?postid=6764152&update=1
       https://home.cnblogs.com/blog/'''###表示两行数据
result=re .search(paty,string)
print(result)

C:\Python36\pythonw.exe D:/python3练习代码/正则表达式.py
<_sre.SRE_Match object; span=(60, 61), match='\n'>

Process finished with exit code 0

可以看出存在这换行，我们还可以看：

paty="\n"
string="https://i.cnblogs.com/EditPosts.aspx?postid=6764152&update=1"\
      "https://home.cnblogs.com/blog/"
result=re .search(paty,string)
print(result)

C:\Python36\pythonw.exe D:/python3练习代码/正则表达式.py
<_sre.SRE_Match object; span=(60, 61), match='\n'>
None

Process finished with exit code 0

这样就不会存在换行
2.3通用字符作为原子
所谓通用字符作为原子即一个原子可以匹配一类字符，我们在实际项目中会经常遇到，如下所示：
\w..................匹配任意一个字母、数字和下划线
\W..................匹配除一个字母、数字和下划线的任意字符
\d..................匹配任意一个十进制数
\D..................匹配除十进制数的任意字符
\s..................匹配任意一个空白字符
\S..................匹配除空白字符以外的的任意字符
比如，我们可以使用”\w\dpython\w“对”python“字符进行匹配，字符后是一个字母、数字或者下划线，字符前一位任意十进制数均可以匹配成功，可以看看下面一个例子：

pat="\w\dpython\w"
string="sadfsj124pythonsdf"
result1=re.search(pat,string)
print(result1)

 

C:\Python36\pythonw.exe D:/python3练习代码/正则表达式.py
<_sre.SRE_Match object; span=(7, 16), match='24pythons'>

Process finished with exit code 0

这样就能按照要求找到

2.4原子表

使用原子表可以定义一组平等的原子，然后匹配的时候会取改原子的任意一个原子进行匹配，在Python中原子由[]表示，比如[xdetr]就是一个原子表，这个原子表定义了5个原子，这几个原子平等地位。

如我们定义正则表达式为[xysaf]python,对应的源字符串为“ypythonjif”,如果用re.search()函数进行匹配，就可以得到的结果为“xpython”，因为Python前一位字母是xysaf中的一个，这样就可以匹配成功、

  类似的，[^]代表的是除中括号里面的原子均可以匹配

下面我们用程序说明：

p1="\w\dpython[xyz]\w"###匹配任意一个字母，数字和下划线
p2="\w]dpython[^xyz]\w"
p3="\w\dpython[xyz]\W"
string="abcdfpyton345pythonx_p"
rep1=re.search(p1,string)
rep2=re.search(p2,string)
rep3=re.search(p3,string)
print(rep1)
print(rep2)
print(rep3)

结果为：

C:\Python36\pythonw.exe D:/python3练习代码/正则表达式.py
<_sre.SRE_Match object; span=(11, 21), match='45pythonx_'>
None
None
None

2.5元字符

所谓的元字符就是正则表达式中具有一些特殊含义的字符，比如重复n次前面的字符等。如下所示：

“.”                   表示除换行符以外的任意字符

“^”                   表示字符串开始的位置

“$”                    表示字符串结束的位置

“*”                   表示0次，或多次匹配前面的原子

“？”                  匹配0次或1次前面的原子

“+”                   匹配1次或者多次前面的原子

“{n}”                前面的 原子恰好出现n次

“{n,}”               前面的原子字少出现n次

“{n,m}”              前面的原子字少出现n次，最多m次

“|”                  模式选择符

“（）”                模式单元符

具体来说可以分为任意匹配元字符，边界元字符、限定符、模式选择符、模式单元等。

下面我们用几个例子来实现：

pa1=".python..."####匹配换行符以外的任意字符
pa2="^abc"###匹配字符串开始的位置
pa3="^abd"
pa4="pyx$"###匹配字符串结束的位置
pa5="pd$"
pa6="^ab\wd\w..............._pyx$"
pa7="py.*n"###py与n之间可以除换行符以外的任意字符，该任意字符可以出现0次或者多次
pa8="cd{2}"###cd字符串中的d恰好出现2次
pa9="cd{1}"
pa10="cd{2,}"###cd字符串中的d至少出现2次
string="abcdfpyton345pythonx_pyx"
print(len(string))
rep1=re.search(pa1,string)
rep2=re.search(pa2,string)
rep3=re.search(pa3,string)
rep4=re.search(pa4,string)
rep5=re.search(pa5,string)
rep6=re.search(pa6,string)
rep7=re.search(pa7,string)
rep8=re.search(pa8,string)
rep9=re.search(pa9,string)
print(rep1)
print(rep2)
print(rep3)
print(rep4)
print(rep5)
print(rep6)
print(rep7)
print(rep8)
print(rep9)

可以看到结果为：

C:\Python36\pythonw.exe D:/python3练习代码/正则表达式.py
24
<_sre.SRE_Match object; span=(12, 22), match='5pythonx_p'>
<_sre.SRE_Match object; span=(0, 3), match='abc'>
None
<_sre.SRE_Match object; span=(21, 24), match='pyx'>
None
<_sre.SRE_Match object; span=(0, 24), match='abcdfpyton345pythonx_pyx'>
<_sre.SRE_Match object; span=(5, 19), match='pyton345python'>
None
<_sre.SRE_Match object; span=(2, 4), match='cd'>

pa1="python|php"###匹配两个中的其中一个
string="abcdcdcdcdfpyton345pythonx_pyx"
rep=re.search(pa1,string)
print(rep)
####模式单元符
pa2="(cd){1,}"###cd是一个大原子，这个整体至少出现1次
pa3="cd{1,}"
rep1=re.search(pa2,string)
rep2=re.search(pa3,string)
print(rep1)
print(rep2)

结果为：

<_sre.SRE_Match object; span=(19, 25), match='python'>
<_sre.SRE_Match object; span=(2, 10), match='cdcdcdcd'>
<_sre.SRE_Match object; span=(2, 4), match='cd'>

2.6修正模式

所谓的模式修正就是模式修正符，也就是说在不改变正则表达式的情况下，通过模式修正符来改变正则表达式的含义，从而实现一些匹配结果的调整功能。常见的模式修正符如下：

I                     匹配时忽略大小写

M                     多行匹配

L                     作本地化识别匹配

U                     根据Unicode 字符集解析字符

S                   让.匹配包括换行符。

下面让我们看看实际的例子

####修正模式
pa1="python"
pa2="p.*y"###贪婪模式：尽可能的匹配
pa3="p.*?y"###懒惰模式
string="abcdcdcdcdfpyton345Pythonx_pyx"
rep=re.search(pa1,string)
rep1=re.search(pa1,string,re.I)####不区分大小写
rep2=re.search(pa2,string)
rep3=re.search(pa3,string)
print(rep)
print(rep1)
print(rep2)
print(rep3)

结果可以为“

C:\Python36\pythonw.exe D:/python3练习代码/正则表达式.py
None
<_sre.SRE_Match object; span=(19, 25), match='Python'>
<_sre.SRE_Match object; span=(11, 29), match='pyton345Pythonx_py'>
<_sre.SRE_Match object; span=(11, 13), match='py'>

在上面我们可以看到我们写得有贪婪模式（尽可能的多批评）和懒惰模式（尽可能少的匹配）

2.7，正则表达式常见的函数

通过上面我们学会了如何写正则表达式，但是这些正则表达式要进行相应的匹配还需要正则表达式函数来完成。

常见函数有