python--“re”详解

1、什么是正则表达式？

正则表达式(regular expression)描述了一种字符串匹配的模式，能够用来检查一个串是否含有某种子串、将匹配的子串作替换或者从某个串中取出符合某个条件的子串等。

正则表达式的组件能够是单个的字符、字符集合、字符范围、字符间的选择或者全部这些组件的任意组合。　

 

2、正则表达式的基本语法。

1.备选字符集　

  　　语法：[可选字符列表]
    　　  强调：1. 不管备选字符集包含多少字符，只能选1个
　　　　　　   2. 必须选1个！

      好比：6位数字的密码： [0123456789][0123456789][0123456789][0123456789][0123456789][0123456789]
     简化：1. 当备选字符连续时，可用-表示范围的区间
        好比：[0123456789]-->[0-9]
        [0-9][0-9][0-9][0-9][0-9][0-9]
        [a-z]-->1位小写字母
        [A-Z]-->1位大写字母
        [A-Za-z]-->1位字母，大小写都行
        [0-9a-zA-Z]-->1位字母或数字都行
     反选：[^不能选的字符列表]
     好比：[^47] 强调：^做“除了”使用时，只能放在开头

　　　语法：X|Y

　　　表达式X|Y等价于[XY]

　

二、预约义字符集

为经常使用的字符集专门提供的简化写法！
   　　 “\d”-->[0-9]-->1位数字　　　　　　　　　　　　　　　　“\D”------一位非数字字符
    　　“\w”-->[0-9a-zA-Z_]-->1位字母,数字或_　　　　　　　 　“\W”------匹配任何非单词字符，等价于[^0-9a-zA-Z_]
  　　  “\s”-->1位空字符：匹配任何空白字符，包括空格、制表符、换页符等等。等价于 [ \f\n\r\t\v]。    　　“\S”--------匹配非空白字符，等价于 [^\f\n\r\t\v]

　　　“\b”----匹配一个单词边界。好比，“er\b”能够匹配"never"中的"er"，但不能匹配“verb”中的“er”。　　 “\B”--------匹配非单词边界。好比，"er\B"能匹配"verb"中的"er"，可是不能匹配“never”中的“er

”
 　   　“ . “: 除换行回车外的任何一个字符,如：
　    　

.

 3. 数量词：规定相邻的字符集可出现的次数

　　  肯定数量：3种：
　　　　　　{n}--> 必须反复出现n位
     　　         {n,m}--> 最少出现n次，最多出现m次
        　　　   {n,}-->至少出现n次，多了不限！
　　　　
    　　　　  好比：/^\d{6}$/——6位数字
　　

　　不肯定数量：3种

　　　　　　*　　大于等于0次

　　　　　　+　　至少出现一次

 　　　　　  ?　　0次或1次

4. 指定匹配位置：
      ^表达式: 必须以表达式的规则为开头
      表达式$: 必须以表达式的规则为结尾

     好比：选择字符串开头的空格？^\s*
           选择结尾空格?\s*$
           选择开头或结尾的空格？^\s*|\s*$
     *预告：从此只要在程序中执行验证：都要前加^后加$*
            表示从头至尾完整匹配。

     好比：test()：
       ^\d{6}$——从头至尾必须只能是6位数字
    

5.预判

在进行正式匹配正则表达式以前，先预读整个字符串，进行初步匹配，若是预判都不能经过，则再也不验证。

　　(?:pattern)　　　非获取匹配，匹配pattern但不获取匹配结果，不进行存储供之后使用。这在使用或字符“(|)”来组合一个模式的各个部分时颇有用。例如“industr(?:y|ies)”就是一个比“industry|industries”更简略的表达式。

　　
　　(?=pattern)　　　非获取匹配，正向确定预查，在任何匹配pattern的字符串开始处匹配查找字符串，该匹配不须要获取供之后使用。例如，“Windows(?=95|98|NT|2000)”能匹配“Windows2000”中的“Windows”，但不能匹配“Windows3.1”中的“Windows”。预查不消耗字符，也就是说，在一个匹配发生后，在最后一次匹配以后当即开始下一次匹配的搜索，而不是从包含预查的字符以后开始。
　　

　　(?!pattern)　　　非获取匹配，正向否认预查，在任何不匹配pattern的字符串开始处匹配查找字符串，该匹配不须要获取供之后使用。例如“Windows(?!95|98|NT|2000)”能匹配“Windows3.1”中的“Windows”，但不能匹配“Windows2000”中的“Windows”。

　　

　　(?<=pattern)　    非获取匹配，反向确定预查，与正向确定预查相似，只是方向相反。例如，“(?<=95|98|NT|2000)Windows”能匹配“2000Windows”中的“Windows”，但不能匹配“3.1Windows”中的“Windows”。 “(?<=95|98|NT|2000)Windows”目前在python3.6中re模块测试会报错，用“|”链接的字符串长度必须同样，这里“95|98|NT”的长度都是2，“2000”的长度是4，会报错。

       (?<!pattern)　　　　非获取匹配，反向否认预查，与正向否认预查相似，只是方向相反。例如“(?<!95|98|NT|2000)Windows”能匹配“3.1Windows”中的“Windows”，但不能匹配“2000Windows”中的“Windows”。这个地方不正确，有问题 .此处用或任意一项都不能超过2位，如“(?<!95|98|NT|20)Windows正确，“(?<!95|980|NT|20)Windows 报错，如果单独使用则无限制，如(?<!2000)Windows 正确匹配。 同上，这里在python3.6中re模块中字符串长度要一致，并非必定为2，好比“(?<!1995|1998|NTNT|2000)Windows”也是能够的。

　　

 

 6.分组　　

　　　()括号里面的内容看成一个分组，当作一个总体 

　　　好比：(a|bc)de　　表示ade 或者cdef

　　　

　　　　给分组起别名：

　　　　语法格式：　　(?P<name> 分组内容)

　　　　eg:（?P<mark>123abc)  这里的意思是给123abc这个分组起了个别名叫mark

　　　　咱们能够经过<?P=mark>的方式来访问到该分组。

 7.贪婪模式和懒惰模式

贪婪模式：默认状况下，正则表达式会匹配最大的符合条件的字符串, *、+和?限定符都是贪婪的，由于它们会尽量多的匹配文字，只有在它们的后面加上一个?就能够实现非贪婪或最小匹配。

好比 

　　匹配字符串：123abc

　　匹配规则:r"\d*[a-z]*？"       匹配结果为123

　　匹配guize:r"\d*?[a-z]*"　　匹配·结果为abc

 

8.python中re模块的经常使用方法

　　在python中，Pattern对象没法经过实例化来建立，只能经过re.compile()方法来返回一个pattern对象。

　　pattern对象，即咱们定义的匹配规则。

 

　　一、re.match(pattern,str[,flags])这个函数是从str的开头开始，尝试匹配pattern，一直向后匹配，若是遇到没法匹配的字符或者到达str的末尾，马上返回None，匹配成则返回一个match对象。

import re
s="HelloWorld"
p=re.compile(r"Hello")
m=p.match(s)
print(m.group())
print(m.span())

执行结果为：
Hello
(0,5)



"""对于p=re.compile(r"Hello")这一语句，re.compile(r"Hello")会返回一个Pattern对象，并把这个对象的引用赋值给p这个变量，此时，p就指向了pattern这个对象"""

"""对于m=p.match(s)这一语句，p.match(s),若是存在匹配结果，则返回一个match对象，若是不存在匹配结果，则返回None"""

下面，咱们来详细讲一下Match对象中的方法
group()  　　　　//返回一个字符串或者元组
span()　　　　　　//返回匹配规则在字符串中的位置
groups()　　　　　　//用于分组的数据


如今，咱们能够知道，在Pattern中也有一个match()方法，它和re中的match()方法，做用彻底相同
　
　　　　　　　　　　　　　　参数列表　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　使用场景
re.match()　　　　　pattern（匹配规则），str(须要匹配的字符串)，flags　　　　　　　　　　使用不一样的规则去匹配字符串
p.match()　　　　　　　　　　str(须要匹配的字符串)　　　　　　　　　　　　　　　　　　　　　使用同一规则去匹配一组字符串
　　　　　　

 

二、re.search(pattern,str[,flags])

search()方法与match()方法极其相似，区别在于match()方法只从str的开始位置匹配，search()方法会扫描整个str查找匹配.

match()方法只有在str开始的位置匹配成功才会返回一个match对象，若是不是开始位置匹配的话，match()就返回一个None。

search()方法的返回对象和match()返回对象是同样的。

import re
s="hahhaha lalala"
p=re.compile(r"la")
m=p.match(s)
print("match对象返回结果："+m.group())
m1=p.search(s)
print("search方法返回结果:"+m1.group())

执行结果为：

 

 3.findall(pattern,str[,flags])//搜索整个str，以列表的形式返回匹配的所有子串

import re
s="hahhaha lalala"
p=re.compile(r"la")print("findall对象返回结果："+str(re.findall(p,s)))##注意findall方法返回的是一个列表
m1=p.search(s)
print("search方法返回结果:"+m1.group())

执行结果:

 

 四、re.split(pattern,str[,maxsplit])//按照可以匹配的子串将str分割后返回列表。maxsplit用于指定最大分割次数，不指定则默认将所有分割。

import re
p=re.compile(r"\d+")
l=re.split(p,"A1B2C3D4")
print(str(l))

执行结果为：

 

 5.re.sub(pattern,repl,str[,count])

使用repl替换str中每个匹配的子串后返回一个被替换后的字符串。当repl是一个方法时。这个方法只接受一个参数(Match对象)，并返回一个字符串。count用于指定最多替换的次数，不指定时，所有替换。