Using Regular Expressions in Python

1. 反斜杠的困扰(The Backslash)

　　有时候需要匹配的文本带有'\',如'\python',因为正则表达式有些特殊字符有特殊意义，所以需要前面加上'\'来消除特殊意义，这里匹配的正则表达式是'\\python'，这时候如果要编译这个正则表达式需要re.compile('\\\\python'),因为在传递字符串的时候python本身就需要用'\\'来表示'\'，也就造成了反斜杠的泛滥。

　　使用前缀'r'可以解决这个问题：’r'之后的'\'只是这个字符本身而没有特殊意义，比如r'\n'表示两个符号'\'和'n'，而原来'\n'表示换行符，所以可以写成re.compile('\\python')

 

2. match的几种methods

match(): 判断RE是否从第一个字符开始匹配

search(): 判断是否从任意一个位置匹配（不管是否从第一个字符开始）

findall(): 找到RE匹配的所有子字符串，并以list的形式返回

finditer(): 找到RE匹配的所有子字符串，并以iterator的形式返回

>>> p = compile('[a-z]+')
>>> print p.match("")
None

>>> m = p.match('tempo')
>>> m.group()
'tempo'
>>> m.start(), m.end()
(0, 5)
>>> m.span()
(0, 5)

>>> m = p.search('::: message')
>>> m.group()
'message'

>>> p = re.compile('\d+')
>>> it = p.finditer('12 drummers drumming, 11 pipers piping, 10 lords a-leaping')
>>> for match in it:
...     print match.group()
...
(0, 2)
(22, 24)
(29, 31)

 

 

3.

'|': “或”，A|B表示匹配A或者B

'^': 匹配行的开头，一般情况下只会匹配字符串的开头，如果在MULTILINE模式下则可以匹配每行的开头

>>> print re.search('^From', 'From Here to Eternity')
<_sre.SRE_Match object at 0x...>
>>> print re.search('^From', 'Reciting From Memory')
None

 

 

'\A': 只匹配字符串的开头

 

'$': 匹配行的末尾，一般情况下只会匹配字符串的末尾，如果在MULTILINE模式下则可以匹配每个换行符

'Z': 只匹配字符串的末尾

 

'\b': 单词的边界，即单词的开头或者末尾，可以是空格或者非字母数字的字符

>>> p = re.compile(r'\bclass\b')
>>> print p.search('no class at all')
<_sre.SRE_Match object at 0x...>
>>> print p.search('the declassified algorithm')
None
>>> print p.search('one subclass is')
None

 

　　注意上面用来编译的正则前面要带'r'，因为在Python中'\b'是退格键，如下：

>>> p = re.compile('\bclass\b')
>>> print p.search('no class at all')
None
>>> print p.search('\b' + 'class' + '\b')
<_sre.SRE_Match object at 0x...>

 

'\B': 匹配不是单词边界

 

4. Grouping

　　用'()'括起来表示分组，比如(ab)*可以匹配ab０次或者更多次。

　　分组是有编号的，０表示整个RE，从左往右编号依次加一，只要看左括号的位置就行

 

>>> p = re.compile('(a(b)c)d')
>>> m = p.match('abcd')
>>> m.group(0)
'abcd'
>>> m.group(1)
'abc'
>>> m.group(2)
'b'

 

 

5. Non-capturing Groups

　　()里面跟着?:的是non-capturing group，一般用于一些分组后面不需要用到的时候

 

>>> m = re.match("([abc])+", "abc")
>>> m.groups()
('c',)
>>> m = re.match("(?:[abc])+", "abc")
>>> m.groups()
()

　　原来编号１的分组在加上?:之后被忽略了，可以用在筛选一些没有用的分组。比较令人疑惑的是第２行m.groups()为什么是'c',这里我觉得应该是贪婪模式尽量往后找的原因

 

６. Named Groups

　　分组过多的时候编号难以记住，可以给分组加上一个名字，相当于一个“标签”，后面引用的时候可以直接通过名字来引用，用法是(?P<name>...)

>>> p = re.compile(r'((?P<word>\b\w+\b))')
>>> m = p.search( '(((( Lots of punctuation )))' )
>>> m.group('word')
'Lots'
>>> m.group(1)
'Lots'

 

　　还可以用来搜索与前面重复的字段：

>>> p = re.compile(r'(?P<word>\b\w+)\s+(?P=word)')
>>> p.search('Paris in the the spring').group()
'the the'

 

7. Lookahead Assertions

　　(?=...) 需要在这个位置匹配括号里面之后的内容，匹配成功即可，不会消耗字符串的内容。

　　(?!...) 与前一个相反，不能匹配括号里面之后的内容才能匹配成功，不会消耗字符串的内容。

　　如在匹配带有扩展名的文件的时候，如果想要排除掉带有后缀.bat和.exe的文件，可以用　.*[.](?!bat$|exe$).*$

8. Splitting Strings

>>> p = re.compile(r'\W+')
>>> p2 = re.compile(r'(\W+)')
>>> p.split('This... is a test.')
['This', 'is', 'a', 'test', '']
>>> p2.split('This... is a test.')
['This', '... ', 'is', ' ', 'a', ' ', 'test', '.', '']

 

 

　　如果使用括号将匹配内容括起来，那么在分割的时候匹配内容也会作为分割的一部分，否则匹配内容会被忽略。如上面通过空格将单词分开，加了括号之后空格也会记录为结果。

　　.split()函数可以加进参数maxsplit表示最多分割几段，如：

 

>>> p = re.compile(r'\W+')
>>> p.split('This is a test, short and sweet, of split().')
['This', 'is', 'a', 'test', 'short', 'and', 'sweet', 'of', 'split', '']
>>> p.split('This is a test, short and sweet, of split().', 3)
['This', 'is', 'a', 'test, short and sweet, of split().']

 

９. Search and Replace

　　p = re.compile('...') , p.sub(replacement, string, [count = 0])

　　string是原来用来被查找替换的字符串，replacement是查找到之后替换的内容，count是最多替换的个数，默认是０表示全部替换

>>> p = re.compile( '(blue|white|red)')
>>> p.sub( 'colour', 'blue socks and red shoes')
'colour socks and colour shoes'
>>> p.sub( 'colour', 'blue socks and red shoes', count=1)
'colour socks and red shoes'

 

　　subn()使用方法类似，但是会同时返回找到替换的个数

>>> p = re.compile( '(blue|white|red)')
>>> p.subn( 'colour', 'blue socks and red shoes')
('colour socks and colour shoes', 2)
>>> p.subn( 'colour', 'no colours at all')
('no colours at all', 0)

 

 

　　之前有命名分组的使用方法，(?P<name>...)，后面想替换成这个分组的内容可以用\g<name>来替换，或者替换成第２组的内容可以用\2，但是替换成第２组内容后面再加上一个０就会写成\20，会与第２０组产生误会，所以有另一个写法是\g<2>，下面例子用了这３种方法，将所有的section替换成subsection

>>> p = re.compile('section{ (?P<name> [^}]* ) }', re.VERBOSE)
>>> p.sub(r'subsection{\1}','section{First}')
'subsection{First}'
>>> p.sub(r'subsection{\g<1>}','section{First}')
'subsection{First}'
>>> p.sub(r'subsection{\g<name>}','section{First}')
'subsection{First}'

 

 

　　还有一种更复杂的方法是用一个函数进行替换，每次会对match到的内容进行一定的操作，如下面将数字转化为１６进制的时候，首先将match到的内容作为参数传进函数进行处理再返回１６进制数

>>> def hexrepl(match):
..."Return the hex string for a decimal number"
...value = int(match.group())
...return hex(value)
...
>>> p = re.compile(r'\d+')
>>> p.sub(hexrepl, 'Call 65490 for printing, 49152 for user code.')
'Call 0xffd2 for printing, 0xc000 for user code.'