python编程基础—正则表达式

正则表达式

• 正则表达式就是描述字符串排列的一套规则。利用正则表达式可以做很多事情，主要用于字符串的匹配
• 在实际项目中，我们经常需要找到某一类符合某种格式的信息，此时，我们可以观察这些数据的规律，然后将这些数据的格式规律用正则表达式形式描述出来，然后利用正则表达式函数进行相应的处理即可。
  本节主要为大家介绍正则表达式怎么去写，将从原子、原子符、模式修正符、贪婪模式与懒惰模式等方面介绍

1.原子

原子是正则表达式中最基本的组成单位，每个正则表达式中至少要包含一个原子
常见的原子有这几类：普通字符作为原子、非打印字符作为原子、通用字符作为原子和原子表

(1) 普通字符作为原子

• 我们可以使用一些普通的字符，比如数字，大小写字母，下划线等都可作为原子使用，如下程序中，‘yue’作为原子使用，这里有三个原子，分别是y,u,e

#普通字符作为原子
import re
pattern = "yue"#yue作为原子使用，有三个原子，分别是y,u,e
string = "http://yum.iqianyue.com"
resultl = re.search(pattern,string)#在string中匹配正确的正则表达式，若匹配成功，将匹配结果返回给变量result
print(resultl)

<_sre.SRE_Match object; span=(16, 19), match='yue'>

(2) 非打印字符作为原子

• 指的是一些在字符串中用于格式控制的符号，比如换行符等（常用的非打印字符为 ‘\n’ :用于匹配一个换行符， ‘\t’ ：用于匹配一个制表符）

##非打印字符作为原子
import re
pattern = "\n"
string = '''http://yum.iqianyue.com
http://baidu.com'''  #字符串变量string中包含一个多行的数据，所以这个数据里面包含了对应的换行符，所以，此时进行换行符匹配
resultl = re.search(pattern,string)
print(resultl)

<_sre.SRE_Match object; span=(23, 24), match='\n'>

import re
pattern = "\n"
string = '''http://yum.iqianyue.comhttp://baidu.com'''#在字符串中不包含换行，所以无法成功匹配，故最后输出None
resultl = re.search(pattern,string)
print(resultl)

None

(3) 通用字符作为原子（即一个原子可以匹配一类字符）

• 通用字符，即一个原子可以匹配一类字符
• 常见的通用字符及其含义：

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

#通用字符作为原子示例
import re 
pattern = "\w\dpython\w"#'\w'匹配任意一个字母、数字、下划线;'\d'匹配任意一个十进制数；
string = "abcdfphp345pythony_py"
result1 = re.search(pattern,string)
print(result1)

<_sre.SRE_Match object; span=(9, 18), match='45pythony'>

(4) 原子表

• 由[]表示，比如[xyz]就是一个原子表，这个原子表中定义了3个原子，这3个原子的地位平等。如我们定义的正则表达式为“[xyz]py”,对应的源字符串为“xpython”,若用 re.search()函数进行匹配，就可以匹配出结果“xpy”，因为此时只要py前一位是x y z字母中的其中一个字母，就可以匹配成功。
• 类似的，[^{]代表的是除了中括号里面的原子均可以匹配成功。比如"[}xyz]py"能匹配“apy”，但是不能匹配xpy等。

#原子表示例
import re 
pattern1 = "\w\dpython[xyz]\w"
pattern2 = "\w\python[^xyz]\w"
pattern3 ="\w\dpython[xyz]\W"
string = "abcdfphp345pythony_py"
result1 = re.search(pattern1,string)
result2= re.search(pattern2,string)
result3 = re.search(pattern3,string)
print(result1)
print(result2)
print(result3)

<_sre.SRE_Match object; span=(9, 19), match='45pythony_'>
None
None

2 原子符

• 原子符就是正则表达式中具有一些特殊含义的字符，比如重复N次前面的字符等。
  常见的元子符:

符号	含义
.	匹配除换行符以外的任意字符
^	匹配字符串的开始位置
$	匹配字符串的终止位置
*	匹配0次、1次或多次前面的原子
?	匹配0次或1次前面的原子
+	匹配1次或多次前面的原子
{n}	前面的原子正好出现n次
{n,}	前面的原子至少出现n次
{m,n}	前面的原子至少出现n次，至多出现m次

(1) 任意匹配原子符

首先看任意匹配符‘.’，可以用‘.’匹配一个除换行符以外的任意字符。
比如，用正则表达式“.python...”匹配一个“python”字符前面有1位，后面有3位格式的字符，这前面的1位和后面的3位可以是除了换行符意外的任意字符。如以下程序：

import re
pattern=".python..."
string = "abcdfphp345pythony_py"
result1 = re.search(pattern1,string)
print(result1)

<_sre.SRE_Match object; span=(9, 19), match='45pythony_'>

(2) 边界限制原子符

可以使用“^”匹配字符串的开始，使用“$”匹配字符串的结束，如下例：

import re 
pattern1 = "^abd"#限制以abd开始
pattern2 = "^abc"#限制以abc开始
pattern3 ="py$"#限制以py结束
pattern4 = "ay$"#限制以ay结束
string = "abcdfphp345pythony_py"#源字符串
result1 = re.search(pattern1,string)
result2= re.search(pattern2,string)
result3 = re.search(pattern3,string)
result4 = re.search(pattern4,string)
print(result1)
print(result2)
print(result3)
print(result4)

None
<_sre.SRE_Match object; span=(0, 3), match='abc'>
<_sre.SRE_Match object; span=(19, 21), match='py'>
None

(3) 限定符

限定符也是元子符中的一种，常见的限定符包括*、?、+、{n}、{n,}、{n,m}

• 看以下例子

import re 
pattern1 = "py.*n"
pattern2 = "cd{2}"
pattern3 ="cd{3}"
pattern4 = "cd{2, }"
string = "abcdddfphp345pythony_py"
result1 = re.search(pattern1,string)
result2= re.search(pattern2,string)
result3 = re.search(pattern3,string)
result4 = re.search(pattern4,string)
print(result1)
print(result2)
print(result3)
print(result4)

<_sre.SRE_Match object; span=(13, 19), match='python'>
<_sre.SRE_Match object; span=(2, 5), match='cdd'>
<_sre.SRE_Match object; span=(2, 6), match='cddd'>
None

(4) 模式选择符

来看模式选择符“|”，使用模式选择符，可以设置多个模式，匹配时可从中选择任意一个模式匹配。比如正则表达式“python|php”中，字符串“python”和“php”均满足匹配条件

#模式匹配符示例
import re 
pattern = "python|php"
string ="abcdfphp345pythony_py" 
result = re.search(pattern,string)
print(result)
#可以看出，从源字符串中匹配到了结果“php”

<_sre.SRE_Match object; span=(5, 8), match='php'>

3 模式修正

• 模式修正符，就是可以在不改变正则表达式的情况下，通过模式修正符改变正则表达式的含义，从而实现一些匹配结果的调整等功能。
  常用的模式修正符：

符号	含义
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(result1)
print(result2)

None
<_sre.SRE_Match object; span=(11, 17), match='Python'>

import re
pattern = "\t"
string = '''http://yum.iqianyue.com
http://baidu.com'''
resultl = re.search(pattern,string)
print(resultl)

None

4 贪婪模式与懒惰模式

总的来说，贪婪模式就是的核心就是尽可能多的匹配，而懒惰模式就是尽可能少的匹配。
可看下面的示例：

import re 
pattern1 = "p.*y"#贪婪模式
pattern2 = "p.*? y"#懒惰模式
string = "abcdfphp345pythony_py"
result1= re.search(pattern1,string)
result2=re.search(pattern2,string)
print(result1)#找到结尾字符y才停止，即找到最后一个y字符才停止
print(result2)#一旦找到了字符y就停止

<_sre.SRE_Match object; span=(5, 21), match='php345pythony_py'>
None

5 正则表达式常见函数

常见的表达式函数有：re.match()函数、re.search()函数、全局匹配函数、re.sub()函数.

(1) re.match()函数

从源字符的起始位置匹配一个模式，就用re.match()函数，其格式为：re.match(pattern,string,flag),第一个参数表示对应的正则表达式，第二个表示源字符，第三个是可选参数，表示对应的标志位，可以放模式修正等信息.

import re
pattern = ".python"
string = "apythonhellomypythonhispythonourpythononend"
result1=re.match(pattern,string)
result2 = re.match(pattern,string).span()#通过.span()可以过滤掉一些信息，只留下匹配成功的结果在源字符串中的位置
print(result1)
print(result2)

<_sre.SRE_Match object; span=(0, 7), match='apython'>
(0, 7)

(2) re.search()函数

用该函数进行匹配，会扫描整个源字符串并进行对应的匹配。
与re.match()函数的不同之处，该函数在全文中进行检索匹配，而re.match()函数是从源字符串的开头进行匹配。

import re
pattern = ".python"
string = "hellomypythonhispythonourpythononend"
result1=re.match(pattern,string)
result2 = re.search(pattern,string)
print(result1)
print(result2)

None
<_sre.SRE_Match object; span=(6, 13), match='ypython'>

(3) 全局匹配函数

• 就是将符合模式的内容全部都匹配出来.思路：
• 1.使用re.compile()对正则表达式进行编译
• 2.编译后，使用indall()根据正则表达式从源字符中将匹配的结果全部找出

import re
string = "hellomypythonhispythonourpythonend"
pattern =re.compile(".python.")#预编译
result =pattern.findall(string)#找出所有符合模式的结果
print(result)

['ypythonh', 'spythono', 'rpythone']

#对上式的整合
import re
string = "hellomypythonhispythonourpythonend"
pattern = ".python."
result =re.compile(pattern).findall(string)
print(result)

['ypythonh', 'spythono', 'rpythone']

(4) re.sub()函数

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

import re
string = "hellomypythonhispythonourpythonend"
pattern = "python."
result = re.sub(pattern,"php",string)
result2=re.sub(pattern,"php",string,)
print(result1)
print(result2)

<_sre.SRE_Match object; span=(5, 19), match='php345pytho_py'>
hellomyphpisphpurphpnd