正则念念碎

正则表达式就原理来讲，只有一点点东东，就是一个状态机，只能用在上下文无关文法的环境。

但是它使用还是非常灵活的，那些厉害的，能够玩出花来，工作效率提高很多。

 

1.常见正则表达式符号

符号	描述	示例
literal	匹配文本字符串的字面值literal	foo
re1|re2	匹配表达式re1或者表达式re2	foo|bar
.	匹配除了(\n)之外的任何字符	b.b
^	匹配字符串起始的部分	^Dear
$	匹配字符串的结束部分	/bin/*sh$
*	匹配0次或者多次前面出现的正则表达式	[a-zA-Z0-9]*
+	匹配1次或者多次前面出现的正则表达式	[a-z]+\.com
?	匹配1次或者0次前面出现的正则表达式	goo?
{N}	匹配N次前面出现过的正则表达式	[0-9]{3}
{M,N}	匹配M~N次前面出现过的正则表达式	[0-9]{5,9}
[...]	匹配来自字符集的任意单一字符	[aeiou]
[...x-y...]	匹配来x~y范围中的任意单一字符	[0-9],[A-Za-z]
[^...]	不匹配字符集中出现的任何一个字符，包括某一范围的字符	[^aeiou],[^a-zA-Z0-9]
(*|+|?|{})?	用于匹配上面频繁出现/重复出现的非贪婪版本	.*?[a-z]
(...)	匹配封闭的正则表达式，然后另存为子组	([0-9]{3})?,f(oo|u)bar
\d	匹配任何十进制数字	data\d.txt
\D	不匹配任何十进制数字
\w	等价于[a-zA-Z0-9]	[a-zA-Z]\w+
\s	匹配任何空格字符[\n\t\r\v\f]	of\sthe
\S	不匹配任何空格字符[^\n\t\r\v\f]	\bthe\b
\b	匹配任何单词边界
\B	与\b相反
\N	匹配已保存的自组N
\c	逐字匹配任何特殊字符c (就是转译)	\.  \\ \*
\A(\Z)	匹配字符串的开始(结尾)
扩展表示法
(?iLmsaux)	在正则表达式中嵌入一个或者多个特殊标记参数(或者通过函数方法) i:不区分大小匹配 m:多行文本 ^ $会去尝试匹配每一行的起始和结束 \A \Z不会 s:单行文本 a:ascii 文本 u:unicode文本 x:详细模式。这个模式下正则表达式可以是多行，忽略空白字符	(?x) (? im)
(?:...)	表示一个匹配不用保存的分组	(?:\w+\.)*
(?P<name>...)	像一个仅由name标识而不是数字id标识的正则分组匹配	(?P<data>)
(?P=name)	在同一字符串中匹配由(?P<name>)分组的之前文本	(?p=data)
(?#....)	表示注释，所有的内容都被忽略	(?#comment)
(?=....)	匹配条件是如果...出现在之后的位置，而不使用输入字符串，称作正向前视断言	(?=.com)
(?!....)	匹配条件是如果...不出现在之后的位置，而不使用输入字符串，称作负向前视断言	(?!.net)
(?<=...)	匹配条件是如果...出现在之后的位置，而不使用输入字符串，称作正向后视断言	(?<=800-)
(?<!...)	匹配条件是如果...不出现在之后的位置，而不使用输入字符串，称作负向后视断言	(?<!192\.168\.)
(?(id|name)Y|N)	如果分组所提供的id或者name存在，就返回正则表达式的条件匹配Y， 如果不存在就返回N;N是可选项	(?(1)y|x)

 

2.re模块核心函数

compile(pattern,flags=0)	使用任何可选的标记来编译正则表达式的模式，然后返回一个正则表达式对象
match(pattern,string,flags=0)	尝试使用带有可选标记的正则表达式的模式来匹配字符串，如果匹配成功，就返回匹配对象 如果失败，就返回None
search(pattern,string,flags=0)	使用可选标记搜索字符串中第一次出现的正则表达式模式，如果成功就返回匹配对象 如果失败，就返回None
findall(pattern,string[,flags])	查找字符串中所有非重复出现的正则表达式模式，返回一个匹配列表
finditer(pattern,string,[,flags])	与findall函数相同，但返回的不是一个列表，而是一个iter， 对于每一次匹配，迭代器都返回一个匹配对象
split(pattern,string,max=0)	根据正则表达式的模式分隔符，split函数将字符串分割为列表，然后返回成功匹配的列表， 分割最多操作max次
sub(pattern,repl,string,count=0)	使用repl替换所有正则表达式的模式在字符串中出现的位置，除非定义了count，否则， 就替换所有出现的位置 repl 可以是个repl(matchobj)函数，返回的结果用来替换
purge()	清除隐式编译的正则表达式
group(num=0)	返回整个匹配对象或者编号为num的特定子组
groups(default=None)	返回一个包含所有匹配子组的元祖，如果没有匹配的就返回一个空tuple
groupdict(defalut=None)	返回一个包含所有匹配的命名自组的字典，所有的子组名词作为字典的键
re.I,　　re.IGNORECASE	不区分大小写的匹配
re.L,　　re.LOCAL	根据所使用的本地语言环境通过 \w \W \b  \B \s \S 实现匹配
re.M　　re.MULTILINE	^和$分别匹配目标字符串行的起始和结尾，而不是严格匹配整个字符串本身的起始和结尾
re.S　　re.DOTALL	"."(点号)通常匹配除了\n(换行符)之外的所有单个字符； 该标记表示"."(点号)能够匹配全部字符
re.X　　re.VERBOSE	通过反斜杠转义,否则所有空格加上#(以及在该行中所有后续文字)都被忽略, 除非在一个字符类中或者允许注释并且提高可读性。

 

3.MatchObject 常用函数:

　　用re.match(pattern,string,flag)和re.search(pattern,string,flag)匹配出来的都是Matchobject。介绍matchobject有个比较常用的方法，觉得非常的实用。

1.start(groupnum=0)

　　　　这个函数返回 某个匹配结果的某个groupnum开始的匹配的位置.

>>> string='xyz123123xyz'
>>> pattern='(123)'
>>> m=re.search(pattern,string)
>>> m.group(0)
'123'
>>>
>>> m.group(1)
'123'
>>> m.start(1) #这里就会返回第一次匹配到那个123在整个xyz123123xyz中的起始位置
3

　

2.end(),endpos(groupnum)

这个同上，只不过是返回结果是结束位置。

 

3.group(num=0),groups(),groupdict()

这几个函数用于返回匹配串种被额外分组保存的部分，group(0)是整个匹配的结果，从1开始是额外保存分组的部分。groups()返回额外保存的分组部分

groupdict()返回groupname:groupvalue这种字典

>>> pattern='1([abc]+)3'
>>> string='1bc3'
>>> m=re.search(pattern,string)
>>> m.group(0)
'1bc3'
>>> m.group(1)
'bc'
>>> m.groups()
('bc',)
>>> m.groupdict()
{}

groupdict()

>>> string
'1bc3'
>>> pattern=r'1(?P<g1>[abc]+)3'
>>> m=re.search(pattern,string)
>>> m
<_sre.SRE_Match object at 0x00BD2E20>
>>> m.groupdict()
{'g1': 'bc'}

　　

4.expand(stringtemplate)

比如m.group(1)==bc

那么m.expand(r"xxxx \1 zzzzz")会返回 xxxx bc zzzzz ,\1的地方会用group(1)的值替代 

 和这个函数功能类似的还有re.sub(pattern,replacement,string,flag) 在string中符合pattern的地方用replacement 替换

 

4.re模块常用函数

预编译

re.compile(pattern,flags) 这个方法用于将一个正则表达式先编译成内部表示，以加快后面的使用效率。

 

匹配

re.match(pattern,string,flags), re.search(pattern,string,flags) 这两个函数用于匹配 ，区别在于match必须从string的起始位置开始匹配，如果起始位置不匹配，就算是没有匹配了，search则是返回string中第一次匹配成功的字符串。

 

查找

re.findall(pattern,string,flags), re.finditer(pattern,string,flags) 返回所有匹配的部分，findall比较费点内存，finditer节约点内存。

 

切分

re.split(pattern,string)，将string切分，只要是匹配pattern的地方都切分。

>>> string="a12b3223d55"
>>> pattern=r'[\d]+'
>>> s=re.split(pattern,string)
>>> s
['a', 'b', 'd', '']

 

替换　　

re.sub(pattern,repl,string[,count,flags])

>>> string="a12b3223d55"
>>> pattern=r'[\d]+'
>>>
>>> s=re.sub(pattern,' hello ',string)
>>> s
'a hello b hello d hello '

 

5.几个可能比较少用的点　　

1.分组的使用

　常用的列子就是日期格式的变换了

　yyyy/mm/dd 变换到 dd/mm/yyy

   string='2016/6/24'

   pattern=r'([\d]{4})/([\d]{1,2})/([\d]{1,2})'

   a=re.match(pattern,string)

   a.groups()-----> ('2016', '6', '24')

　格式转换:

   re.sub(pattern,r'\3-\2-\1',string) -----> '24-6-2016'

 

2.向前看肯定、想前看否定，向后看肯定、向后看否定（ 行话叫“环视”）

　　string='abcdefg'

　　向前看肯定:pattern='cd(?=ef)' 这个表达式的意思是匹配cd，但是cd后面必须跟着'ef'   re.search(pattern,string) 返回 'cd'

　   向前看否定:pattern='cd(?!ef)' 这个表达式的意思是匹配cd，但是cd后面必须不能跟着'ef'   re.search(pattern,string) 返回 None

　　向后看肯定：

>>> pattern=re.search(r'(?<=foo)bar','foobar')
>>> pattern
<_sre.SRE_Match object at 0x00B77950>
>>> pattern.group()
'bar'
>>> pattern=re.search(r'(?<=foo)bar','foosbar')
>>> pattern

　　向后看否定：　　

>>> pattern=re.search(r'(?<!foo)bar','foobar')
>>>
>>> pattern
>>> pattern=re.search(r'(?<!foo)bar','fosobar')
>>> pattern
<_sre.SRE_Match object at 0x00B77950>

　　注意向前看后向后的位置，向后看 (?<!foo) 写在 bar前面 ，向前看 (?!foo)写在bar后面

 

3.正则中的group index。

a=re.search(r'((<)|[a-z])[a-z]*((?(2)>|[123]+))',"<pypix>")

正则中的括号index为从左向右，第1个(就是 group(1) ,第二个(就是group(2)，和是否被包含在()中没有关系

 

4.if-then-else 模式

(?(引用分组的数字))

a=re.search(r'((<)|[a-z])[a-z]*((?(2)>|[123]+))',"<pypix>")

这个表达式中 (?(2)>|[123]+)) 表示 如果 之前匹配了 '<' 部分，那么 接着匹配 '>',否则匹配 [123]+

 

5.分组但是不保存。

(?: 表达式 )

import re          
string = 'Hello foobar'         
pattern = re.search(r'(?:H.*)(f.*)(b.*)', string)          
print "f* => {0}".format(pattern.group(1)) # prints f* => foo          
print "b* => {0}".format(pattern.group(2)) # prints b* => bar

 

6.给分组取名

(?P<groupname>表达式)

引用的时候 result.group('groupname')

import re          
string = 'Hello foobar'         
pattern = re.search(r'(?P<fstar>f.*)(?P<bstar>b.*)', string)          
print "f* => {0}".format(pattern.group('fstar')) # prints f* => foo          
print "b* => {0}".format(pattern.group('bstar')) # prints b* => bar

　　

7.正则题目

 

一串数字弄成每三位一个逗号,

39736484599==>39,736,484,599

12==>12

2345==>2,345

利用分组

   

import re
s='39736484599'
#s='2234'
a=re.search(r'^(\d{1,3})((\d{3})*)$',s)
print a.groups()
result=a.groups()[0]
g2=a.groups()[1]
if g2:
    def f(m):
        print("m:"+m.group())
        return m.group()+","
    #(?!$)，最后一个599不进到f中，直接 +599了    
    result=result+','+str(re.sub(r'\d{3}(?!$)',f,g2))
print result

　　

 

 

　　

 

7.分组时,?+*在()里面和在()外面的差别

 。。。。。。。。

 

转载于:https://www.cnblogs.com/hi0xcc/p/5608054.html