Python 正则表达式（一）

概念

正则表达式是对字符串操作的一种逻辑公式，就是用事先定义好的一些特定字符、及这些特定字符的组合，组成一个“规则字符串”，这个“规则字符串”用来表达对字符串的一种过滤逻辑（可以用来做检索，截取或者替换操作）。

作用
给定的字符串是否符合正则表达式的过滤逻辑（称作“匹配”）。
可以通过正则表达式，从字符串中获取我们想要的特定部分。
还可以对目标字符串进行替换操作。

Python语言通过标准库中的re模块支持正则表达式。re模块提供了一些根据正则表达式进行查找、替换、分隔字符串的函数，这些函数使用一个正则表达式作为第一个参数。

正则函数

函数	描述
match(pattern,string,flags=0)	根据pattern从string的头部开始匹配字符串，只返回第1次匹配成功的对象；否则，返回None
findall(pattern,string,flags=0)	根据pattern在string中匹配字符串。如果匹配成功，返回包含匹配结果的列表；否则，返回空列表。当pattern中有分组时，返回包含多个元组的列表，每个元组对应1个分组。flags表示规则选项，规则选项用于辅助匹配。
sub(pattern,repl,string,count=0)	根据指定的正则表达式，替换源字符串中的子串。pattern是一个正则表达式，repl是用于替换的字符串，string是源字符串。如果count等于0，则返回string中匹配的所有结果；如果count大于0，则返回前count个匹配结果
subn(pattern,repl,string,count=0)	作用和sub()相同，返回一个二元的元组。第1个元素是替换结果，第2个元素是替换的次数
search(pattern,string,flags=0)	根据pattern在string中匹配字符串，只返回第1次匹配成功的对象。如果匹配失败，返回None
compile(pattern,flags=0)	编译正则表达式pattern，返回1个pattern的对象
split(pattern,string,maxsplit=0)	根据pattern分隔string，maxsplit表示最大的分隔数
escape(pattern)	匹配字符串中的特殊字符，如*、+、?等

match函数

re.match 尝试从字符串的起始位置匹配一个模式，如果不是起始位置匹配成功的话，match()就返回None。语法格式如下：

re.match(pattern, string, flags=0)

参数	描述
pattern	匹配的正则表达式
string	要匹配的字符串。
flags	标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。如下表列出正则表达式修饰符 - 可选参数

正则表达式修饰符

修饰符	描述
re.I	使匹配对大小写不敏感
re.L	做本地化识别（locale-aware）匹配
re.M	多行匹配，影响 ^ 和 $
re.S	使 . 匹配包括换行在内的所有字符
re.U	根据Unicode字符集解析字符。这个标志影响 \w, \W, \b, \B.
re.X	该标志通过给予你更灵活的格式以便你将正则表达式写得更易于理解。

意义：

re.match是用来进行正则匹配检查的方法，如果字符串开头的0个或多个字符匹配正则表达式模式，则返回相应的match对象。如果字符串不匹配模式，返回None（注意不是空字符串""）
匹配对象Match Object具有group()方法， 用来返回字符串的匹配部分,具有span()方法。返回匹配字符串的位置（元组存储开始，结束位置），具有start(),end()方法，存储匹配数据的开始和结束位置。（也可以通过对象的dir(对象查看对象的方法)）

如果想在目标字符串的任意位置查找，需要使用search

示例

import re
s='hello python'
pattern='hello'
v=re.match(pattern,s)
print(v)
print(v.group()) #group函数接受一个参数，表示要获取第几个子字符串，默认为0，表示获取整个匹配到的字符串。
print(v.span()) #span() 是 re 模块中的一个函数,它用于在字符串中搜索模式并返回匹配的起始和结束位置

输出结果
<re.Match object; span=(0, 5), match=‘hello’>
hello
(0, 5)

import re
s = 'hello Python!'
m=re.match('hello python',s,re.I) #忽略大小写
if m is not None:print('匹配成功结果是：',m.group())
else:print('匹配失败')

输出结果
匹配成功结果是： hello Python

常用匹配符

符号	描述
.	匹配任意一个字符（除了\n）
[]	匹配列表中的字符
\w	匹配字母、数字、下划线，即az，AZ,0~9
\W	匹配不是字母、数字、下划线
\s	匹配空白字符，即空格（\n,\t）
\S	匹配不是空白的字符
\d	匹配数字，即0~9
\D	匹配非数字的字符

一个正则表达式是由**字母、数字和特殊字符（括号、星号、问号等）**组成。正则表达式中有许多特殊的字符，这些特殊字符是构成正则表达式的要素。

import re
pattern='.' #匹配任意一个字符（除了\n）
s='a'
print('匹配字符a：',re.match(pattern,s))
s='C'
print('匹配字符C：',re.match(pattern,s))
s='_'
print('匹配字符_：',re.match(pattern,s))
s='\n'
print('匹配字符\\n：',re.match(pattern,s))

输出结果
匹配字符a： <re.Match object; span=(0, 1), match=‘a’>
匹配字符C： <re.Match object; span=(0, 1), match=‘C’>
匹配字符_： <re.Match object; span=(0, 1), match=‘_’>
匹配字符\n： None

import re
pattern='\d' #匹配数字,即0-9
s='9'
print('匹配数字9：',re.match(pattern,s))
s='4'
print('匹配数字4：',re.match(pattern,s))
s='a'
print('匹配字符a：',re.match(pattern,s))
s='_'
print('匹配字符_：',re.match(pattern,s))

输出结果
匹配数字9： <re.Match object; span=(0, 1), match=‘9’>
匹配数字4： <re.Match object; span=(0, 1), match=‘4’>
匹配字符a： None
匹配字符_： None

限定符

如果要匹配手机号码，按上面的理解需要形如“\d\d\d\d\d\d\d\d\d\d\d”这样的正则表达式。其中表现了11次“\d”，表达方式烦琐。正则表达式作为一门小型的语言，还提供了对表达式的一部分进行重复处理的功能。例如，“*”可以对正则表达式的某个部分重复匹配多次。这种匹配符号称为限定符。

符号	描述	符号	描述
*	匹配零次或多次	{m}	重复m次
+	匹配一次或多次	{m,n}	重复m到n次，其中n可以省略，表示m到任意次
?	匹配一次或零次	{m,}	至少m次

import re
print('------*匹配零次或多次--------')
pattern='\d*' #0次或多次
s='123abc'
print('匹配123abc：',re.match(pattern,s)) ## 结果是123
s='abc' #这时候不是None而是''
print('匹配abc：',re.match(pattern,s)) ## 结果是''
print('-----+匹配一次或多次---------')
pattern='\d+' #1次或多次
s='123abc'
print('匹配123abc：',re.match(pattern,s)) ##结果是123
s='abc' #这时候是None
print('匹配abc：',re.match(pattern,s))
print('-----?匹配一次或零次---------')
pattern='\d?' #0次或1次
s='123abc'
print('匹配123abc：',re.match(pattern,s))
s='abc' #这时候是空
print('匹配abc：',re.match(pattern,s))

import re
print('-----{m}重复m次---------')
pattern='\d{3}' #匹配数字，出现3次
s='123abc'
print('pattern为\\d{3}匹配123abc结果：',re.match(pattern,s))
pattern='\d{4}' #匹配数字，出现4次，这时候结果为空
print('pattern为\\d{4}匹配123abc结果：',re.match(pattern,s))
print('-----{m,}至少m次---------')
s='1234567abc'
pattern='\d{3,}' #重复大于3次 尽可能满足的都返回 这时候结果为1234567
print('pattern为\\d{3,}匹配1234567abc结果：\n',re.match(pattern,s))
print('-----{m,n}重复m到n次---------')
pattern='\d{2,4}' #重复2到4次，这时候结果为1234
print('pattern为\\d{2,4}匹配1234567abc结果：\n',re.match(pattern,s))

【示例】匹配出一个字符串首字母为大写字符，后边都是小写字符，这些小写字母可有可无

pattern='[A-Z][a-z]*'
s='Hello world'
s='HEllo world'
v=re.match(pattern,s)
print(v) #输出结果为 <re.Match object; span=(0, 1), match='H'>

匹配出有效的变量名，开头以字母、下划线开始变量名为有效变量名，其余不是

import re
pattern='[A-Za-z_][0-9A-Za-z_]*'
print('pattern为[A-Za-z_][0-9A-Za-z_]*')
s='a'
print('匹配变量名a的结果：',re.match(pattern,s))
s='ab'
print('匹配变量名ab的结果：',re.match(pattern,s))
s='_ab'
print('匹配变量名_ab的结果：',re.match(pattern,s))
s='2ab'
print('匹配变量名2ab的结果：',re.match(pattern,s))
print('pattern为[A-Za-z_]\w*')
pattern='[A-Za-z_]\w*'
s='a'
print('匹配变量名a的结果：',re.match(pattern,s))
s='ab'
print('匹配变量名ab的结果：',re.match(pattern,s))
s='_ab'
print('匹配变量名_ab的结果：',re.match(pattern,s))
s='2ab'
print('匹配变量名2ab的结果：',re.match(pattern,s))

匹配1-99的数字

import re
pattern='[1-9]\d?' #匹配1-9的数字或0~9，匹配1次或0次
s='1'
print('匹配数字1：',re.match(pattern,s))
s='55'
print('匹配数字55：',re.match(pattern,s))
s='99'
print('匹配数字99：',re.match(pattern,s))
s='199'
print('匹配数字199：',re.match(pattern,s))

匹配数字1： <re.Match object; span=(0, 1), match=‘1’>
匹配数字55： <re.Match object; span=(0, 2), match=‘55’>
匹配数字99： <re.Match object; span=(0, 2), match=‘99’>
匹配数字199： <re.Match object; span=(0, 2), match=‘19’>

【示例】匹配出一个随机密码8-20位以内 (大写字母 小写字母 下划线 数字)

import re
pattern='\w{8,20}'
m='m1548_1223'
print("匹配结果：",re.match(pattern,m))

原生字符串

和大多数编程语言相同，正则表达式里使用“\”作为转义字符，这就可以能造成反斜杠困扰。

s = 'c:\\a\\b\\c'
print(s) # 结果是 c:\a\b\c
s = '\n123'
print(s) #结果是 换行 123
s = '\\n123'
print(s)#结果是 \n123

假如你需要匹配文本中的字符“\”，那么使用编程语言表示的正则表达式里将需要4个反斜杠“\\”：前面两个和后两个分别用于在编程语
言里转义成反斜杠，转换成两个反斜杠后再在正则表达式里转义成一个反斜杠。
Python里的原生字符串很好地解决了这个问题，使用Python的r前缀。例如匹配一个数字的“\d”可以写成r“\d”。有了原生字符串，再也不用担心是不是漏写了反斜杠，写出来的表达式也更直观。

import re
s = r'\n123'
print(s) #输出结果是 \n123
#目标字符串
s = '\\n123'
pattern = '\\n\d{3}'
print(re.match(pattern,s)) #返回None
#如果想匹配两个反斜杠需要使用两个反斜杠作为转义,即正则中要写四个反斜杠
pattern = '\\\\n\d{3}'
print(re.match(pattern,s))
#使用原生字符串r比较方便
pattern = r'\\n\d{3}'
print(re.match(pattern,s))

边界字符

字符	功能
^	匹配字符串开头
$	匹配字符串结尾
\b	匹配一个单词的边界
\B	匹配非单词的边界

$的使用

import re
#匹配qq邮箱， 5-10位
print('未限制结尾'.center(30,'-'))
pattern = '[\d]{5,10}@qq.com'
print('正确的邮箱匹配结果：\n',re.match(pattern,'[e-mail]'))
print('不正确的邮箱匹配结果：\n',re.match(pattern,'[e-mail]'))
print('限制结尾'.center(30,'-'))
pattern = '[1-9]\d{4,9}@qq.com$'
print('正确的邮箱匹配结果：\n',re.match(pattern,'[e-mail]'))
print('不正确的邮箱匹配结果：\n',re.match(pattern,'[e-mail]'))

------------未限制结尾-------------
正确的邮箱匹配结果：
<re.Match object; span=(0, 12), match=‘[e-mail]’>
不正确的邮箱匹配结果：
<re.Match object; span=(0, 12), match=‘[e-mail]’>
-------------限制结尾-------------
正确的邮箱匹配结果：
<re.Match object; span=(0, 12), match=‘[e-mail]’>
不正确的邮箱匹配结果：
None

\b的使用

pattern = r'.*\bab'
#ab左边界的情况
v = re.match(pattern,'123 abr')
print(v)
pattern = r'.*ab\b'
#ab为右边界的情况
v = re.match(pattern,'wab')
print(v)

<re.Match object; span=(0, 6), match=‘123 ab’>
<re.Match object; span=(0, 3), match=‘wab’>