正则表达式（Python）_max(”1111”,“222”,“33”,4)-CSDN博客

本文链接：https://blog.csdn.net/kittyboy0001/article/details/20806229

正则表达式（Python）

特殊符号和字符

符号

记号         说明                     正则表达式样例
literal     匹配字符串的值                  foo

re1|re2     匹配正则表达式re1或者re2         foo|bar

.           匹配任何单个字符（换行除外）       b.b

^           匹配字符串的开始                 ^Dear

$           匹配字符串的结尾                    /bin/*sh$     

*           匹配正则表达式 0次或多次          [A-Za-z0-9]*

+           匹配正则表达式 1次或多次           [a-z]+\.com

?           匹配正则表达式 0次或1次           goo?

{N}         匹配正则表达式 重复N次                [0-9]{3}

{M,N}       匹配正则表达式 重复出现M次到N次       [0-9]{3,5}

[...]       匹配字符组中出现的任意一个字符     [aeiou]

[x-y]       匹配从字符x到y的任意一个字符     [0-9]，[A-Za-z]

[^...]     不匹配此字符集中的字符              [^aeiou]，[^A-Za-z0-9]

(*|+|?|{})? 非贪婪匹配                       .*?[a-z]

(...)      匹配封闭括号中正则表达式RE           ([0-9]{3})?，f(oo|u)bar

特殊字符

\d        匹配任何数字，同[0-9]             data\d+.txt
\D        匹配任何非数字符

\w        匹配任何数字字母字符,同[A-Za-z0-9]   [A-Za-z_]\w+
\W        \w的反义词

\s        匹配任何空白符，同[\n\t\r\v\f]      of\sthe
\S        \s的反义词

\b        匹配单词边界                        \bThe\b

\nn       匹配已保存的子组                      price:\16

\c        逐一匹配特殊字符c                 \.,\\,\*
          取消其特殊含义，按字面匹配

\A(\Z)    匹配字符串的起始(结束)              \ADear

</?[^>]+>           匹配所有合法（和无效）HTML标签的字符串

\d{3}-\d{3}-\d{3}   美国电话号码，如 800-555-1234

\d+(\.\d+)?         表示简单的浮点数    

.*?                 非贪婪的匹配任意长度字符

贪婪匹配
正则表达式默认为贪婪匹配。
也就是说，如果正则表达式模式中使用到通配字，那它按照从左到有的顺序求值时，回尽量抓取满足匹配的最长字符串。
一个解决办法是使用“非贪婪”操作符？。这个操作符用在*、+或者？的后面。作用是要求正则表达式引擎匹配的字符越少越好。

re模块

match和search

match( rule , targetString [,flag] )
search( rule , targetString [,flag] )

按照规则在目标字符串中进行匹配。
第一个参数是正则规则，第二个是目标字符串，第三个是选项（同compile函数的选项）返回：若成功返回一个Match对象，失败无返回
不过它们的返回不是一个简单的字符串列表，而是一个MatchObject，通过操作这个matchObject，我们可以得到更多的信息。
需要注意的是，如果匹配不成功，它们则返回一个NoneType。所以在对匹配完的结果进行操作之前，你必需先判断一下是否匹配成功了，比如：

>>> m=re.match( rule , target )
>>> if m:                       #必需先判断是否成功
        doSomethin

这两个函数唯一的区别是：match从字符串的开头开始匹配，如果开头位置没有匹配成功，就算失败了；而search会跳过开头，继续向后寻找是否有匹配的字符串。针对不同的需要，可以灵活使用这两个函数。

group和groups

group() 方法返回匹配的所有对象，或者是()表示的特定子组
groups() 方法返回包含所有子组的元组

>>> import re
>>> p=re.match("(\d+)-(\d+)-(\d+)",'11-22-33')
>>> p.groups()
('11', '22', '33')
>>> p.group(0)
'11-22-33'
>>> p.group(0)
'11-22-33'
>>> p.group(1)
'11'
>>> p.group(2)
'22'
>>> p.group(3)
'33'
>>> p.group(4)
Traceback (most recent call last):
    File "<stdin>", line 1, in <module>
IndexError: no such group

findall和finditer

findall(rule , target [,flag] )

在目标字符串中查找符合规则的字符串。第一个参数是规则，第二个参数是目标字符串，后面还可以跟一个规则选项（选项功能将在compile函数的说明中详细说明）。
返回结果结果是一个列表，中间存放的是符合规则的字符串。如果没有符合规则的字符串被找到，就返回一个空列表。

finditer( rule , target [,flag] )

参数同findall
返回一个迭代器

finditer函数和findall函数的区别是，findall返回所有匹配的字符串，并存为一个列表，而finditer则并不直接返回这些字符串，而是返回一个迭代器。

>>> m=re.findall('\d+','1111 222 333 44 567')
>>> m.group()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'list' object has no attribute 'group'
>>> m
['1111', '222', '333', '44', '567']
>>> m=re.finditer('\d+','1111 222 333 44 567')
>>> for i in m:
...     print i,i.group(),i.span()
... 
<_sre.SRE_Match object at 0x10a8a5920> 1111 (0, 4)
<_sre.SRE_Match object at 0x10a8a5850> 222 (5, 8)
<_sre.SRE_Match object at 0x10a8a5920> 333 (9, 12)
<_sre.SRE_Match object at 0x10a8a5850> 44 (13, 15)
<_sre.SRE_Match object at 0x10a8a5920> 567 (16, 19)

sub和subn

sub ( rule , replace , target [,count] )
subn(rule , replace , target [,count] )

在目标字符串中规格规则查找匹配的字符串，再把它们替换成指定的字符串。你可以指定一个最多替换次数，否则将替换所有的匹配到的字符串。
第一个参数是正则规则，第二个参数是指定的用来替换的字符串，第三个参数是目标字符串，第四个参数是最多替换次数。
这两个函数的唯一区别是返回值。
sub返回一个被替换的字符串
sub返回一个元组，第一个元素是被替换的字符串，第二个元素是一个数字，表明产生了多少次替换。

>>> s=" I have a dog , you have a dog , he have a dog "
>>> re.sub('dog','cat',s,2)
' I have a cat , you have a cat , he have a dog '
>>> re.subn('dog','cat',s)
(' I have a cat , you have a cat , he have a cat ', 3)