Python正则表达式

Python正则表达式 匹配大全

动机

1. 文本处理已经成为计算机常见的工作之一
2. 对文本内容的搜索，定位，提取是逻辑比较复杂的工作
3. 为了快速方便的解决上述问题，产生了正则表达式技术

定义 ：即文本的高级匹配模式，提供搜索，替换等功能。其本质是一 系列由字符和特殊符号组成的字符串，这个字符串即正则表达式

匹配原理： 由普通字符和特殊符号构成，通过描述字符的重复，位置 ，种类等行为达到匹配某一类字符串的目的

目标：

1. 熟练掌握正则表达式符号
2. 读懂常见的正则表达式，编写基本的搜索提取功能正则
3. 能够熟练使用re模块操作正则表达式

正则表达式特点

• 方便文本处理
• 支持语言众多
• 使用灵活变化多样

python ——》 re模块

re.findall(pattern,string)
功能: 提取所有的正则匹配内容
参数：pattern 正则表达式
string 目标字符串
返回值 ： 列表，所有提取到的内容

元字符的使用

1. 普通字符

元字符 ： a B c
匹配规则 ： 每个字符匹配对应的字符

In [13]: re.findall(‘ab’,“abcasfdb”)
Out[13]: [‘ab’]

• python中正则表达式可以匹配汉字

2. 或

元字符 ： |
匹配规则： 匹配 | 两侧任意一个正则表达式

In [15]: re.findall(‘ab|ef’,“abcdefgh”)
Out[15]: [‘ab’, ‘ef’]

3. 匹配单个字符

元字符 ： .
匹配规则： 匹配除换行外的任意字符

In [18]: re.findall(‘f.o’,“foo fao”)
Out[18]: [‘foo’, ‘fao’]

4. 匹配字符串开始位置

元字符 ： ^
匹配规则：匹配目标字符串的开始位置

In [23]: re.findall("^Hello",“Hello Jame”)
Out[23]: [‘Hello’]

5. 匹配字符串的结束位置

元字符： $
匹配规则： 匹配字符串的结尾位置

In [23]: re.findall(“Jame$”,“Hello Jame”)
Out[25]: [‘Jame’]

6. 匹配重复

元字符 ： *
匹配规则 ： 匹配前面的字符重复 0 次或者多次

fo* --> foooooooo f

In [27]: re.findall(“fo*”,“fooooafddfgfoo”)
Out[27]: [‘foooo’, ‘f’, ‘f’, ‘foo’]

7. 匹配重复

元字符 ： +
匹配规则 ： 匹配前面的字符出现1次或多次

fo+ --> fooooo fo

In [29]: re.findall(“fo+”,“fooooafddfgfo”)
Out[29]: [‘foooo’, ‘fo’]

8. 匹配重复

元字符 ： ？
匹配规则： 匹配前面的字符出现 0次或1次

fo? --> f fo

In [32]: re.findall(“fo?”,“fooooafddfgfo”)
Out[32]: [‘fo’, ‘f’, ‘f’, ‘fo’]

9. 匹配重复

元字符 ： {n}
匹配规则 ： 匹配前面的字符重复指定的次数

fo{3} --> fooo

In [33]: re.findall(“fo{3}”,“fooooasdfoo”)
Out[33]: [‘fooo’]

10. 匹配重复

元字符 ： {m,n}
匹配规则 ： 匹配前面的字符出现 m – n 次

fo{2,4} --> foo fooo foooo

In [34]: re.findall(“fo{2,4}”,“fooooasdfoo,fo”)
Out[34]: [‘foooo’, ‘foo’]

11. 匹配字符集

元字符 ： [字符集]
匹配规则 ： 匹配字符集中任意一个字符

[abc123] --> a b c 1 2 3
[a-z] [A-Z] [0-9]
[_#%a-zA-Z]

In [43]: re.findall("[A-Z]+[a-z]*",“This is A Test”)
Out[43]: [‘This’, ‘A’, ‘Test’]

12.匹配字符集

元字符 ： [^ …]
匹配规则 ： 匹配除了字符集中的任意一个字符

[^abc] --> 除了 a b c外的任意一个字符

In [46]: re.findall("[^ ]+",“This is A Test”)
Out[46]: [‘This’, ‘is’, ‘A’, ‘Test’]

13. 匹配任意（非）数字

元字符 ： \d \D
匹配规则： \d 匹配任意数字字符 [0-9]
\D 匹配任意非数字字符 [^0-9]

In [50]: re.findall(“1\d{10}”,“13844668899”)
Out[50]: [‘13844668899’]

14. 匹配任意（非）普通字符

元字符： \w \W
匹配规则: \w 匹配任意普通字符 [_0-9a-zA-Z] 也能匹配汉字
\W 匹配任意非普通字符

In [54]: re.findall("\w+",“PORT#10035,Error 44%下降”)
Out[54]: [‘PORT’, ‘10035’, ‘Error’, ‘44’, ‘下降’]

15. 匹配（非）空字符

元字符 ： \s \S
匹配规则： \s 匹配任意空字符 [ \r\n\t\v\f]
\S 匹配任意非空字符

In [57]: re.findall("\w+\s+\w+",“hello world”)
Out[57]: [‘hello world’]

16. 匹配字符串位置

元字符 ： \A \Z
匹配规则: \A 匹配字符串开头位置 ^
\Z 匹配字符串结尾位置 $

In [63]: re.findall("\A\d±\d+\Z",“1000-1500”)
Out[63]: [‘1000-1500’]

• 绝对匹配：当正则表达式前有^最后有$时，那么这个正则表达式一定 是要匹配目标字符串的全部内容，否则就什么都不匹配

17. 匹配单词边界

元字符 ： \b \B
匹配规则 ： \b 匹配单词边界位置 普通字符和非普通字符的交界
\B 匹配非单词边界位置

In [68]: re.findall(r"\bis\b",“This is a dog”)
Out[68]: [‘is’]

元字符总结

匹配单个字符： . […] [^…] \d \D \w \W \s \S

匹配重复 : * + ? {n} {m,n}

匹配位置 : ^ $ \A \Z \b \B

其他 ： | （） \

正则表达式转义

正则中的特殊符号： . * + ? ^ $ [] () | \

在正则表达式中如果需要匹配特殊符号则需要加\作为转义
e.g.  匹配  .  需要使用 \.

    python字符串            正则               目标字符串
    “\\$\\d+”             \$\d+                 $10

raw字符串：不对字符串内容进行转义处理
    “\\$\\d+”  ==》 r"\$\d+" 

贪婪 和 非贪婪

贪婪模式：正则表达式的重复匹配默认总是尽可能向后匹配更多的内容

 *  +  ？  {m,n}

非贪婪（懒惰模式）：尽可能少的重复匹配内容

 贪婪 --》 非贪婪   *？  +？  ??  {m,n}?

In [92]: re.findall(“ab+?”,“abbbbbbbbbbccc”)
Out[92]: [‘ab’]

正则表达式分组

使用() 可以为正则表达式建立内部分组，子组为正则表达式的一    部，可以看作一个内部整体

* 有子组的正则表达式仍然是整体去匹配内容，子组需在整体能够
  匹配到内容的前提下发挥作用


子组的作用：
    1. 作为内部整体可以改变某些元字符行为

     In [100]: re.search("(ab)+\d+","ababab1234").group()
     Out[100]: 'ababab1234'

     In [105]: re.search(r"\w+@\w+\.(cn|                   com)","Wangwc@tedu.com").group()
     Out[105]: 'Wangwc@tedu.com'

    2. 子组在匹配到内容的情况下可以单独提取

      In [112]: re.search(r"(https|http|ftp)://\S                    +","http://www.baidu.com").group(1)
      Out[112]: 'http'


   子组注意事项
      1. 一个正则表达式中可以有多个子组
      2. 子组一般由外到内，由左到右记为第一第二。。。子组
      3. 子组不要重叠或者嵌套过多


   捕获组和非捕获组  

       格式 ： (?P<name>pattern)             

       In [117]: In [105]: re.search(r"(?                     P<dog>ab)cd","abcdef").group('dog')
       Out[117]: 'ab'

       作用：名字可以表达一定的含义， 也可以通过名字获取子                 组内容

正则表达式设计原则

1. 正确性 ，能够正确的匹配出目标字符串
2. 排他性 ，除了要匹配的内容，尽可能不会匹配到其他内容
3. 全面性 ，尽可能对目标字串各种情况考虑全面，做到不遗漏

re模块

regex = compile（pattern,flags = 0）
功能： 生成正则表达式对象
参数： pattern 正则表达式
flags 功能标志位，丰富正则表达式的匹配功能
返回值：正则表达式对象

re.findall(pattern,string,flags = 0)
功能 ： 从目标字符串提取所有正则匹配内容
参数 ： pattern 正则
string 目标字串
flags 功能标志
返回值 ： 返回匹配到的内容列表
如果正则表达式有子组则只获取子组中的内容

regex.findall(string,pos，endpos)
功能 ： 从目标字符串提取所有正则匹配内容
参数 ： string 目标字串
pos 截取目标字符串起始位置
endpos 截取目标字符串终止位置
返回值 ： 返回匹配到的内容列表
如果正则表达式有子组则只获取子组中的内容

re.split(pattern,string,flags)
功能 ： 使用正则表达式匹配部分切割目标字符串
参数 ： pattern 正则表达式
string 目标字串
flags
返回值 ： 列表， 切割后的部分

re.sub(pattern,replaceStr,string,max,flags)
功能 ： 使用字符串替换正则匹配内容
参数 ： pattern
replaceStr ： 替换的字符串
string ： 目标字符串
max ： 最多替换几处，默认全部替换
返回值 ： 返回替换后的字符串

re.subn(pattern,replaceStr,string,max,flags)
功能 ： 使用字符串替换正则匹配内容
参数 ： pattern
replaceStr ： 替换的字符串
string ： 目标字符串
max ： 最多替换几处，默认全部替换
返回值 ： 返回替换后的字符串和替换了几处

re.finditer(pattern,string，flags)
功能 ： 使用正则表达式匹配目标字符串
参数 ： pattern 正则表达式
string 目标字符串
返回值：迭代对象

fullmatch（pattern，string，flags）
功能 ： 绝对匹配目标字符串
参数 ： pattern 正则
string 目标字符串
返回值 ： match 对象

match（pattern，string，flags）
功能 ： 匹配目标字符串开头位置
参数 ： pattern 正则
string 目标字符串
返回值 ： match 对象

search（pattern，string，flags）
功能 ： 匹配目标字符串第一处匹配内容
参数 ： pattern 正则
string 目标字符串
返回值 ： match 对象

regex 对象的属性

pattern   代表的正则表达式

flags    表示标志位常量值

groups   表示有多少子组

groupindex   生成捕获组名和对应第几组的键值对构成的字典